← Back to branch summary

~ubuntu-branches/ubuntu/hardy/kvm/hardy-backports

« back to all changes in this revision

Viewing changes to kernel/x86_emulate.c

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2007-11-15 02:21:55 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20071115022155-pxoxb8kfcrkn72mi
Tags: 1:52+dfsg-0ubuntu1
* New upstream release.
* 08_default_tdf.patch
  - Make -tdf the default and add a -no-tdf option.

Show diffs side-by-side

added added

removed removed

Lines of Context:
kernel/x86_emulate.c
26
26
#define DPRINTF(_f, _a ...) printf(_f , ## _a)
27
27
#else
28
28
#include "kvm.h"
 
29
#include "x86.h"
29
30
#define DPRINTF(x...) do {} while (0)
30
31
#endif
31
32
#include "x86_emulate.h"
62
63
/* Destination is only written; never read. */
63
64
#define Mov         (1<<7)
64
65
#define BitOp       (1<<8)
 
66
#define MemAbs      (1<<9)      /* Memory operand is absolute displacement */
65
67
 
66
 
static u8 opcode_table[256] = {
 
68
static u16 opcode_table[256] = {
67
69
        /* 0x00 - 0x07 */
68
70
        ByteOp | DstMem | SrcReg | ModRM, DstMem | SrcReg | ModRM,
69
71
        ByteOp | DstReg | SrcMem | ModRM, DstReg | SrcMem | ModRM,
97
99
        ByteOp | DstReg | SrcMem | ModRM, DstReg | SrcMem | ModRM,
98
100
        0, 0, 0, 0,
99
101
        /* 0x40 - 0x47 */
100
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
101
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
 
102
        DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg,
102
103
        /* 0x48 - 0x4F */
103
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
104
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
 
104
        DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg,
105
105
        /* 0x50 - 0x57 */
106
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
107
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
 
106
        SrcReg, SrcReg, SrcReg, SrcReg, SrcReg, SrcReg, SrcReg, SrcReg,
108
107
        /* 0x58 - 0x5F */
109
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
110
 
        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
 
108
        DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg,
111
109
        /* 0x60 - 0x67 */
112
110
        0, 0, 0, DstReg | SrcMem32 | ModRM | Mov /* movsxd (x86/64) */ ,
113
111
        0, 0, 0, 0,
133
131
        /* 0x90 - 0x9F */
134
132
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ImplicitOps, ImplicitOps, 0, 0,
135
133
        /* 0xA0 - 0xA7 */
136
 
        ByteOp | DstReg | SrcMem | Mov, DstReg | SrcMem | Mov,
137
 
        ByteOp | DstMem | SrcReg | Mov, DstMem | SrcReg | Mov,
 
134
        ByteOp | DstReg | SrcMem | Mov | MemAbs, DstReg | SrcMem | Mov | MemAbs,
 
135
        ByteOp | DstMem | SrcReg | Mov | MemAbs, DstMem | SrcReg | Mov | MemAbs,
138
136
        ByteOp | ImplicitOps | Mov, ImplicitOps | Mov,
139
137
        ByteOp | ImplicitOps, ImplicitOps,
140
138
        /* 0xA8 - 0xAF */
171
169
static u16 twobyte_table[256] = {
172
170
        /* 0x00 - 0x0F */
173
171
        0, SrcMem | ModRM | DstReg, 0, 0, 0, 0, ImplicitOps, 0,
174
 
        0, ImplicitOps, 0, 0, 0, ImplicitOps | ModRM, 0, 0,
 
172
        ImplicitOps, ImplicitOps, 0, 0, 0, ImplicitOps | ModRM, 0, 0,
175
173
        /* 0x10 - 0x1F */
176
174
        0, 0, 0, 0, 0, 0, 0, 0, ImplicitOps | ModRM, 0, 0, 0, 0, 0, 0, 0,
177
175
        /* 0x20 - 0x2F */
445
443
 
446
444
#define JMP_REL(rel)                                                    \
447
445
        do {                                                            \
448
 
                c->eip += (int)(rel);                                   \
449
 
                c->eip = ((c->op_bytes == 2) ?                          \
450
 
                          (uint16_t)c->eip : (uint32_t)c->eip);         \
 
446
                register_address_increment(c->eip, rel);                \
451
447
        } while (0)
452
448
 
453
449
/*
520
516
        return (!!rc ^ (condition & 1));
521
517
}
522
518
 
 
519
static void decode_register_operand(struct operand *op,
 
520
                                    struct decode_cache *c,
 
521
                                    int inhibit_bytereg)
 
522
{
 
523
        unsigned reg = c->modrm_reg;
 
524
        int highbyte_regs = c->rex_prefix == 0;
 
525
 
 
526
        if (!(c->d & ModRM))
 
527
                reg = (c->b & 7) | ((c->rex_prefix & 1) << 3);
 
528
        op->type = OP_REG;
 
529
        if ((c->d & ByteOp) && !inhibit_bytereg) {
 
530
                op->ptr = decode_register(reg, c->regs, highbyte_regs);
 
531
                op->val = *(u8 *)op->ptr;
 
532
                op->bytes = 1;
 
533
        } else {
 
534
                op->ptr = decode_register(reg, c->regs, 0);
 
535
                op->bytes = c->op_bytes;
 
536
                switch (op->bytes) {
 
537
                case 2:
 
538
                        op->val = *(u16 *)op->ptr;
 
539
                        break;
 
540
                case 4:
 
541
                        op->val = *(u32 *)op->ptr;
 
542
                        break;
 
543
                case 8:
 
544
                        op->val = *(u64 *) op->ptr;
 
545
                        break;
 
546
                }
 
547
        }
 
548
        op->orig_val = op->val;
 
549
}
 
550
 
 
551
static int decode_modrm(struct x86_emulate_ctxt *ctxt,
 
552
                        struct x86_emulate_ops *ops)
 
553
{
 
554
        struct decode_cache *c = &ctxt->decode;
 
555
        u8 sib;
 
556
        int index_reg = 0, base_reg = 0, scale, rip_relative = 0;
 
557
        int rc = 0;
 
558
 
 
559
        if (c->rex_prefix) {
 
560
                c->modrm_reg = (c->rex_prefix & 4) << 1;        /* REX.R */
 
561
                index_reg = (c->rex_prefix & 2) << 2; /* REX.X */
 
562
                c->modrm_rm = base_reg = (c->rex_prefix & 1) << 3; /* REG.B */
 
563
        }
 
564
 
 
565
        c->modrm = insn_fetch(u8, 1, c->eip);
 
566
        c->modrm_mod |= (c->modrm & 0xc0) >> 6;
 
567
        c->modrm_reg |= (c->modrm & 0x38) >> 3;
 
568
        c->modrm_rm |= (c->modrm & 0x07);
 
569
        c->modrm_ea = 0;
 
570
        c->use_modrm_ea = 1;
 
571
 
 
572
        if (c->modrm_mod == 3) {
 
573
                c->modrm_val = *(unsigned long *)
 
574
                        decode_register(c->modrm_rm, c->regs, c->d & ByteOp);
 
575
                return rc;
 
576
        }
 
577
 
 
578
        if (c->ad_bytes == 2) {
 
579
                unsigned bx = c->regs[VCPU_REGS_RBX];
 
580
                unsigned bp = c->regs[VCPU_REGS_RBP];
 
581
                unsigned si = c->regs[VCPU_REGS_RSI];
 
582
                unsigned di = c->regs[VCPU_REGS_RDI];
 
583
 
 
584
                /* 16-bit ModR/M decode. */
 
585
                switch (c->modrm_mod) {
 
586
                case 0:
 
587
                        if (c->modrm_rm == 6)
 
588
                                c->modrm_ea += insn_fetch(u16, 2, c->eip);
 
589
                        break;
 
590
                case 1:
 
591
                        c->modrm_ea += insn_fetch(s8, 1, c->eip);
 
592
                        break;
 
593
                case 2:
 
594
                        c->modrm_ea += insn_fetch(u16, 2, c->eip);
 
595
                        break;
 
596
                }
 
597
                switch (c->modrm_rm) {
 
598
                case 0:
 
599
                        c->modrm_ea += bx + si;
 
600
                        break;
 
601
                case 1:
 
602
                        c->modrm_ea += bx + di;
 
603
                        break;
 
604
                case 2:
 
605
                        c->modrm_ea += bp + si;
 
606
                        break;
 
607
                case 3:
 
608
                        c->modrm_ea += bp + di;
 
609
                        break;
 
610
                case 4:
 
611
                        c->modrm_ea += si;
 
612
                        break;
 
613
                case 5:
 
614
                        c->modrm_ea += di;
 
615
                        break;
 
616
                case 6:
 
617
                        if (c->modrm_mod != 0)
 
618
                                c->modrm_ea += bp;
 
619
                        break;
 
620
                case 7:
 
621
                        c->modrm_ea += bx;
 
622
                        break;
 
623
                }
 
624
                if (c->modrm_rm == 2 || c->modrm_rm == 3 ||
 
625
                    (c->modrm_rm == 6 && c->modrm_mod != 0))
 
626
                        if (!c->override_base)
 
627
                                c->override_base = &ctxt->ss_base;
 
628
                c->modrm_ea = (u16)c->modrm_ea;
 
629
        } else {
 
630
                /* 32/64-bit ModR/M decode. */
 
631
                switch (c->modrm_rm) {
 
632
                case 4:
 
633
                case 12:
 
634
                        sib = insn_fetch(u8, 1, c->eip);
 
635
                        index_reg |= (sib >> 3) & 7;
 
636
                        base_reg |= sib & 7;
 
637
                        scale = sib >> 6;
 
638
 
 
639
                        switch (base_reg) {
 
640
                        case 5:
 
641
                                if (c->modrm_mod != 0)
 
642
                                        c->modrm_ea += c->regs[base_reg];
 
643
                                else
 
644
                                        c->modrm_ea +=
 
645
                                                insn_fetch(s32, 4, c->eip);
 
646
                                break;
 
647
                        default:
 
648
                                c->modrm_ea += c->regs[base_reg];
 
649
                        }
 
650
                        switch (index_reg) {
 
651
                        case 4:
 
652
                                break;
 
653
                        default:
 
654
                                c->modrm_ea += c->regs[index_reg] << scale;
 
655
                        }
 
656
                        break;
 
657
                case 5:
 
658
                        if (c->modrm_mod != 0)
 
659
                                c->modrm_ea += c->regs[c->modrm_rm];
 
660
                        else if (ctxt->mode == X86EMUL_MODE_PROT64)
 
661
                                rip_relative = 1;
 
662
                        break;
 
663
                default:
 
664
                        c->modrm_ea += c->regs[c->modrm_rm];
 
665
                        break;
 
666
                }
 
667
                switch (c->modrm_mod) {
 
668
                case 0:
 
669
                        if (c->modrm_rm == 5)
 
670
                                c->modrm_ea += insn_fetch(s32, 4, c->eip);
 
671
                        break;
 
672
                case 1:
 
673
                        c->modrm_ea += insn_fetch(s8, 1, c->eip);
 
674
                        break;
 
675
                case 2:
 
676
                        c->modrm_ea += insn_fetch(s32, 4, c->eip);
 
677
                        break;
 
678
                }
 
679
        }
 
680
        if (rip_relative) {
 
681
                c->modrm_ea += c->eip;
 
682
                switch (c->d & SrcMask) {
 
683
                case SrcImmByte:
 
684
                        c->modrm_ea += 1;
 
685
                        break;
 
686
                case SrcImm:
 
687
                        if (c->d & ByteOp)
 
688
                                c->modrm_ea += 1;
 
689
                        else
 
690
                                if (c->op_bytes == 8)
 
691
                                        c->modrm_ea += 4;
 
692
                                else
 
693
                                        c->modrm_ea += c->op_bytes;
 
694
                }
 
695
        }
 
696
done:
 
697
        return rc;
 
698
}
 
699
 
 
700
static int decode_abs(struct x86_emulate_ctxt *ctxt,
 
701
                      struct x86_emulate_ops *ops)
 
702
{
 
703
        struct decode_cache *c = &ctxt->decode;
 
704
        int rc = 0;
 
705
 
 
706
        switch (c->ad_bytes) {
 
707
        case 2:
 
708
                c->modrm_ea = insn_fetch(u16, 2, c->eip);
 
709
                break;
 
710
        case 4:
 
711
                c->modrm_ea = insn_fetch(u32, 4, c->eip);
 
712
                break;
 
713
        case 8:
 
714
                c->modrm_ea = insn_fetch(u64, 8, c->eip);
 
715
                break;
 
716
        }
 
717
done:
 
718
        return rc;
 
719
}
 
720
 
523
721
int
524
722
x86_decode_insn(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
525
723
{
526
724
        struct decode_cache *c = &ctxt->decode;
527
 
        u8 sib, rex_prefix = 0;
528
725
        int rc = 0;
529
726
        int mode = ctxt->mode;
530
 
        int index_reg = 0, base_reg = 0, scale, rip_relative = 0;
531
727
 
532
728
        /* Shadow copy of register state. Committed on successful emulation. */
533
729
 
588
784
                case 0x40 ... 0x4f: /* REX */
589
785
                        if (mode != X86EMUL_MODE_PROT64)
590
786
                                goto done_prefixes;
591
 
                        rex_prefix = c->b;
 
787
                        c->rex_prefix = c->b;
592
788
                        continue;
593
789
                case 0xf0:      /* LOCK */
594
790
                        c->lock_prefix = 1;
603
799
 
604
800
                /* Any legacy prefix after a REX prefix nullifies its effect. */
605
801
 
606
 
                rex_prefix = 0;
 
802
                c->rex_prefix = 0;
607
803
        }
608
804
 
609
805
done_prefixes:
610
806
 
611
807
        /* REX prefix. */
612
 
        if (rex_prefix) {
613
 
                if (rex_prefix & 8)
 
808
        if (c->rex_prefix)
 
809
                if (c->rex_prefix & 8)
614
810
                        c->op_bytes = 8;        /* REX.W */
615
 
                c->modrm_reg = (rex_prefix & 4) << 1;   /* REX.R */
616
 
                index_reg = (rex_prefix & 2) << 2; /* REX.X */
617
 
                c->modrm_rm = base_reg = (rex_prefix & 1) << 3; /* REG.B */
618
 
        }
619
811
 
620
812
        /* Opcode byte(s). */
621
813
        c->d = opcode_table[c->b];
635
827
        }
636
828
 
637
829
        /* ModRM and SIB bytes. */
638
 
        if (c->d & ModRM) {
639
 
                c->modrm = insn_fetch(u8, 1, c->eip);
640
 
                c->modrm_mod |= (c->modrm & 0xc0) >> 6;
641
 
                c->modrm_reg |= (c->modrm & 0x38) >> 3;
642
 
                c->modrm_rm |= (c->modrm & 0x07);
643
 
                c->modrm_ea = 0;
644
 
                c->use_modrm_ea = 1;
645
 
 
646
 
                if (c->modrm_mod == 3) {
647
 
                        c->modrm_val = *(unsigned long *)
648
 
                          decode_register(c->modrm_rm, c->regs, c->d & ByteOp);
649
 
                        goto modrm_done;
650
 
                }
651
 
 
652
 
                if (c->ad_bytes == 2) {
653
 
                        unsigned bx = c->regs[VCPU_REGS_RBX];
654
 
                        unsigned bp = c->regs[VCPU_REGS_RBP];
655
 
                        unsigned si = c->regs[VCPU_REGS_RSI];
656
 
                        unsigned di = c->regs[VCPU_REGS_RDI];
657
 
 
658
 
                        /* 16-bit ModR/M decode. */
659
 
                        switch (c->modrm_mod) {
660
 
                        case 0:
661
 
                                if (c->modrm_rm == 6)
662
 
                                        c->modrm_ea +=
663
 
                                                insn_fetch(u16, 2, c->eip);
664
 
                                break;
665
 
                        case 1:
666
 
                                c->modrm_ea += insn_fetch(s8, 1, c->eip);
667
 
                                break;
668
 
                        case 2:
669
 
                                c->modrm_ea += insn_fetch(u16, 2, c->eip);
670
 
                                break;
671
 
                        }
672
 
                        switch (c->modrm_rm) {
673
 
                        case 0:
674
 
                                c->modrm_ea += bx + si;
675
 
                                break;
676
 
                        case 1:
677
 
                                c->modrm_ea += bx + di;
678
 
                                break;
679
 
                        case 2:
680
 
                                c->modrm_ea += bp + si;
681
 
                                break;
682
 
                        case 3:
683
 
                                c->modrm_ea += bp + di;
684
 
                                break;
685
 
                        case 4:
686
 
                                c->modrm_ea += si;
687
 
                                break;
688
 
                        case 5:
689
 
                                c->modrm_ea += di;
690
 
                                break;
691
 
                        case 6:
692
 
                                if (c->modrm_mod != 0)
693
 
                                        c->modrm_ea += bp;
694
 
                                break;
695
 
                        case 7:
696
 
                                c->modrm_ea += bx;
697
 
                                break;
698
 
                        }
699
 
                        if (c->modrm_rm == 2 || c->modrm_rm == 3 ||
700
 
                            (c->modrm_rm == 6 && c->modrm_mod != 0))
701
 
                                if (!c->override_base)
702
 
                                        c->override_base = &ctxt->ss_base;
703
 
                        c->modrm_ea = (u16)c->modrm_ea;
704
 
                } else {
705
 
                        /* 32/64-bit ModR/M decode. */
706
 
                        switch (c->modrm_rm) {
707
 
                        case 4:
708
 
                        case 12:
709
 
                                sib = insn_fetch(u8, 1, c->eip);
710
 
                                index_reg |= (sib >> 3) & 7;
711
 
                                base_reg |= sib & 7;
712
 
                                scale = sib >> 6;
713
 
 
714
 
                                switch (base_reg) {
715
 
                                case 5:
716
 
                                        if (c->modrm_mod != 0)
717
 
                                                c->modrm_ea +=
718
 
                                                        c->regs[base_reg];
719
 
                                        else
720
 
                                                c->modrm_ea +=
721
 
                                                    insn_fetch(s32, 4, c->eip);
722
 
                                        break;
723
 
                                default:
724
 
                                        c->modrm_ea += c->regs[base_reg];
725
 
                                }
726
 
                                switch (index_reg) {
727
 
                                case 4:
728
 
                                        break;
729
 
                                default:
730
 
                                        c->modrm_ea +=
731
 
                                                c->regs[index_reg] << scale;
732
 
 
733
 
                                }
734
 
                                break;
735
 
                        case 5:
736
 
                                if (c->modrm_mod != 0)
737
 
                                        c->modrm_ea += c->regs[c->modrm_rm];
738
 
                                else if (mode == X86EMUL_MODE_PROT64)
739
 
                                        rip_relative = 1;
740
 
                                break;
741
 
                        default:
742
 
                                c->modrm_ea += c->regs[c->modrm_rm];
743
 
                                break;
744
 
                        }
745
 
                        switch (c->modrm_mod) {
746
 
                        case 0:
747
 
                                if (c->modrm_rm == 5)
748
 
                                        c->modrm_ea +=
749
 
                                                insn_fetch(s32, 4, c->eip);
750
 
                                break;
751
 
                        case 1:
752
 
                                c->modrm_ea += insn_fetch(s8, 1, c->eip);
753
 
                                break;
754
 
                        case 2:
755
 
                                c->modrm_ea += insn_fetch(s32, 4, c->eip);
756
 
                                break;
757
 
                        }
758
 
                }
759
 
                if (!c->override_base)
760
 
                        c->override_base = &ctxt->ds_base;
761
 
                if (mode == X86EMUL_MODE_PROT64 &&
762
 
                    c->override_base != &ctxt->fs_base &&
763
 
                    c->override_base != &ctxt->gs_base)
764
 
                        c->override_base = NULL;
765
 
 
766
 
                if (c->override_base)
767
 
                        c->modrm_ea += *c->override_base;
768
 
 
769
 
                if (rip_relative) {
770
 
                        c->modrm_ea += c->eip;
771
 
                        switch (c->d & SrcMask) {
772
 
                        case SrcImmByte:
773
 
                                c->modrm_ea += 1;
774
 
                                break;
775
 
                        case SrcImm:
776
 
                                if (c->d & ByteOp)
777
 
                                        c->modrm_ea += 1;
778
 
                                else
779
 
                                        if (c->op_bytes == 8)
780
 
                                                c->modrm_ea += 4;
781
 
                                        else
782
 
                                                c->modrm_ea += c->op_bytes;
783
 
                        }
784
 
                }
785
 
                if (c->ad_bytes != 8)
786
 
                        c->modrm_ea = (u32)c->modrm_ea;
787
 
modrm_done:
788
 
                ;
789
 
        }
790
 
 
 
830
        if (c->d & ModRM)
 
831
                rc = decode_modrm(ctxt, ops);
 
832
        else if (c->d & MemAbs)
 
833
                rc = decode_abs(ctxt, ops);
 
834
        if (rc)
 
835
                goto done;
 
836
 
 
837
        if (!c->override_base)
 
838
                c->override_base = &ctxt->ds_base;
 
839
        if (mode == X86EMUL_MODE_PROT64 &&
 
840
            c->override_base != &ctxt->fs_base &&
 
841
            c->override_base != &ctxt->gs_base)
 
842
                c->override_base = NULL;
 
843
 
 
844
        if (c->override_base)
 
845
                c->modrm_ea += *c->override_base;
 
846
 
 
847
        if (c->ad_bytes != 8)
 
848
                c->modrm_ea = (u32)c->modrm_ea;
791
849
        /*
792
850
         * Decode and fetch the source operand: register, memory
793
851
         * or immediate.
796
854
        case SrcNone:
797
855
                break;
798
856
        case SrcReg:
799
 
                c->src.type = OP_REG;
800
 
                if (c->d & ByteOp) {
801
 
                        c->src.ptr =
802
 
                                decode_register(c->modrm_reg, c->regs,
803
 
                                                  (rex_prefix == 0));
804
 
                        c->src.val = c->src.orig_val = *(u8 *)c->src.ptr;
805
 
                        c->src.bytes = 1;
806
 
                } else {
807
 
                        c->src.ptr =
808
 
                            decode_register(c->modrm_reg, c->regs, 0);
809
 
                        switch ((c->src.bytes = c->op_bytes)) {
810
 
                        case 2:
811
 
                                c->src.val = c->src.orig_val =
812
 
                                                       *(u16 *) c->src.ptr;
813
 
                                break;
814
 
                        case 4:
815
 
                                c->src.val = c->src.orig_val =
816
 
                                                       *(u32 *) c->src.ptr;
817
 
                                break;
818
 
                        case 8:
819
 
                                c->src.val = c->src.orig_val =
820
 
                                                       *(u64 *) c->src.ptr;
821
 
                                break;
822
 
                        }
823
 
                }
 
857
                decode_register_operand(&c->src, c, 0);
824
858
                break;
825
859
        case SrcMem16:
826
860
                c->src.bytes = 2;
835
869
                if (c->twobyte && c->b == 0x01
836
870
                                    && c->modrm_reg == 7)
837
871
                        break;
 
872
              srcmem_common:
838
873
                /*
839
874
                 * For instructions with a ModR/M byte, switch to register
840
875
                 * access if Mod = 3.
843
878
                        c->src.type = OP_REG;
844
879
                        break;
845
880
                }
846
 
srcmem_common:
847
881
                c->src.type = OP_MEM;
848
882
                break;
849
883
        case SrcImm:
879
913
                /* Special instructions do their own operand decoding. */
880
914
                return 0;
881
915
        case DstReg:
882
 
                c->dst.type = OP_REG;
883
 
                if ((c->d & ByteOp)
884
 
                    && !(c->twobyte &&
885
 
                        (c->b == 0xb6 || c->b == 0xb7))) {
886
 
                        c->dst.ptr =
887
 
                                decode_register(c->modrm_reg, c->regs,
888
 
                                                  (rex_prefix == 0));
889
 
                        c->dst.val = *(u8 *) c->dst.ptr;
890
 
                        c->dst.bytes = 1;
891
 
                } else {
892
 
                        c->dst.ptr =
893
 
                            decode_register(c->modrm_reg, c->regs, 0);
894
 
                        switch ((c->dst.bytes = c->op_bytes)) {
895
 
                        case 2:
896
 
                                c->dst.val = *(u16 *)c->dst.ptr;
897
 
                                break;
898
 
                        case 4:
899
 
                                c->dst.val = *(u32 *)c->dst.ptr;
900
 
                                break;
901
 
                        case 8:
902
 
                                c->dst.val = *(u64 *)c->dst.ptr;
903
 
                                break;
904
 
                        }
905
 
                }
 
916
                decode_register_operand(&c->dst, c,
 
917
                         c->twobyte && (c->b == 0xb6 || c->b == 0xb7));
906
918
                break;
907
919
        case DstMem:
908
920
                /*
1176
1188
        memcpy(c->regs, ctxt->vcpu->regs, sizeof c->regs);
1177
1189
        saved_eip = c->eip;
1178
1190
 
1179
 
        if ((c->d & ModRM) && (c->modrm_mod != 3))
 
1191
        if (((c->d & ModRM) && (c->modrm_mod != 3)) || (c->d & MemAbs))
1180
1192
                cr2 = c->modrm_ea;
1181
1193
 
1182
1194
        if (c->src.type == OP_MEM) {
1267
1279
              cmp:              /* cmp */
1268
1280
                emulate_2op_SrcV("cmp", c->src, c->dst, ctxt->eflags);
1269
1281
                break;
 
1282
        case 0x40 ... 0x47: /* inc r16/r32 */
 
1283
                emulate_1op("inc", c->dst, ctxt->eflags);
 
1284
                break;
 
1285
        case 0x48 ... 0x4f: /* dec r16/r32 */
 
1286
                emulate_1op("dec", c->dst, ctxt->eflags);
 
1287
                break;
 
1288
        case 0x50 ... 0x57:  /* push reg */
 
1289
                c->dst.type  = OP_MEM;
 
1290
                c->dst.bytes = c->op_bytes;
 
1291
                c->dst.val = c->src.val;
 
1292
                register_address_increment(c->regs[VCPU_REGS_RSP],
 
1293
                                           -c->op_bytes);
 
1294
                c->dst.ptr = (void *) register_address(
 
1295
                        ctxt->ss_base, c->regs[VCPU_REGS_RSP]);
 
1296
                break;
 
1297
        case 0x58 ... 0x5f: /* pop reg */
 
1298
        pop_instruction:
 
1299
                if ((rc = ops->read_std(register_address(ctxt->ss_base,
 
1300
                        c->regs[VCPU_REGS_RSP]), c->dst.ptr,
 
1301
                        c->op_bytes, ctxt->vcpu)) != 0)
 
1302
                        goto done;
 
1303
 
 
1304
                register_address_increment(c->regs[VCPU_REGS_RSP],
 
1305
                                           c->op_bytes);
 
1306
                c->dst.type = OP_NONE;  /* Disable writeback. */
 
1307
                break;
1270
1308
        case 0x63:              /* movsxd */
1271
1309
                if (ctxt->mode != X86EMUL_MODE_PROT64)
1272
1310
                        goto cannot_emulate;
1273
1311
                c->dst.val = (s32) c->src.val;
1274
1312
                break;
1275
 
        case 0x6a: /* push imm8 */
1276
 
                c->src.val = 0L;
1277
 
                c->src.val = insn_fetch(s8, 1, c->eip);
1278
 
                emulate_push(ctxt);
1279
 
                break;
1280
1313
        case 0x80 ... 0x83:     /* Grp1 */
1281
1314
                switch (c->modrm_reg) {
1282
1315
                case 0:
1336
1369
        case 0xa0 ... 0xa1:     /* mov */
1337
1370
                c->dst.ptr = (unsigned long *)&c->regs[VCPU_REGS_RAX];
1338
1371
                c->dst.val = c->src.val;
1339
 
                /* skip src displacement */
1340
 
                c->eip += c->ad_bytes;
1341
1372
                break;
1342
1373
        case 0xa2 ... 0xa3:     /* mov */
1343
1374
                c->dst.val = (unsigned long)c->regs[VCPU_REGS_RAX];
1344
 
                /* skip c->dst displacement */
1345
 
                c->eip += c->ad_bytes;
1346
1375
                break;
1347
1376
        case 0xc0 ... 0xc1:
1348
1377
                emulate_grp2(ctxt);
1391
1420
        if (c->twobyte)
1392
1421
                goto twobyte_special_insn;
1393
1422
        switch (c->b) {
1394
 
        case 0x40 ... 0x47: /* inc r16/r32 */
1395
 
                c->dst.bytes = c->op_bytes;
1396
 
                c->dst.ptr = (unsigned long *)&c->regs[c->b & 0x7];
1397
 
                c->dst.val = *c->dst.ptr;
1398
 
                emulate_1op("inc", c->dst, ctxt->eflags);
1399
 
                break;
1400
 
        case 0x48 ... 0x4f: /* dec r16/r32 */
1401
 
                c->dst.bytes = c->op_bytes;
1402
 
                c->dst.ptr = (unsigned long *)&c->regs[c->b & 0x7];
1403
 
                c->dst.val = *c->dst.ptr;
1404
 
                emulate_1op("dec", c->dst, ctxt->eflags);
1405
 
                break;
1406
 
        case 0x50 ... 0x57:  /* push reg */
1407
 
                if (c->op_bytes == 2)
1408
 
                        c->src.val = (u16) c->regs[c->b & 0x7];
1409
 
                else
1410
 
                        c->src.val = (u32) c->regs[c->b & 0x7];
1411
 
                c->dst.type  = OP_MEM;
1412
 
                c->dst.bytes = c->op_bytes;
1413
 
                c->dst.val = c->src.val;
1414
 
                register_address_increment(c->regs[VCPU_REGS_RSP],
1415
 
                                           -c->op_bytes);
1416
 
                c->dst.ptr = (void *) register_address(
1417
 
                        ctxt->ss_base, c->regs[VCPU_REGS_RSP]);
1418
 
                break;
1419
 
        case 0x58 ... 0x5f: /* pop reg */
1420
 
                c->dst.ptr = (unsigned long *)&c->regs[c->b & 0x7];
1421
 
        pop_instruction:
1422
 
                if ((rc = ops->read_std(register_address(ctxt->ss_base,
1423
 
                        c->regs[VCPU_REGS_RSP]), c->dst.ptr,
1424
 
                        c->op_bytes, ctxt->vcpu)) != 0)
1425
 
                        goto done;
1426
 
 
1427
 
                register_address_increment(c->regs[VCPU_REGS_RSP],
1428
 
                                           c->op_bytes);
1429
 
                c->dst.type = OP_NONE;  /* Disable writeback. */
 
1423
        case 0x6a: /* push imm8 */
 
1424
                c->src.val = 0L;
 
1425
                c->src.val = insn_fetch(s8, 1, c->eip);
 
1426
                emulate_push(ctxt);
1430
1427
                break;
1431
1428
        case 0x6c:              /* insb */
1432
1429
        case 0x6d:              /* insw/insd */
1567
1564
                case 4:
1568
1565
                        rel = insn_fetch(s32, 4, c->eip);
1569
1566
                        break;
1570
 
                case 8:
1571
 
                        rel = insn_fetch(s64, 8, c->eip);
1572
 
                        break;
1573
1567
                default:
1574
1568
                        DPRINTF("Call: Invalid op_bytes\n");
1575
1569
                        goto cannot_emulate;
1576
1570
                }
1577
1571
                c->src.val = (unsigned long) c->eip;
1578
1572
                JMP_REL(rel);
 
1573
                /*
 
1574
                 * emulate_push() save value in size of c->op_bytes, therefore
 
1575
                 * we are setting it now to be the size of eip so all the value
 
1576
                 * of eip will be saved
 
1577
                 */ 
 
1578
                c->op_bytes = c->ad_bytes;
1579
1579
                emulate_push(ctxt);
1580
1580
                break;
1581
1581
        }
1748
1748
        case 0x06:
1749
1749
                emulate_clts(ctxt->vcpu);
1750
1750
                break;
 
1751
        case 0x08:              /* invd */
 
1752
                break;
1751
1753
        case 0x09:              /* wbinvd */
1752
1754
                break;
1753
1755
        case 0x0d:              /* GrpP (prefetch) */