kvm/user/test/x86/emulator.c

   1 #include "ioram.h"
   2 #include "vm.h"
   3 #include "libcflat.h"
   4
   5 #define memset __builtin_memset
   6
   7 int fails, tests;
   8
   9 void report(const char *name, int result)
  10 {
  11         ++tests;
  12         if (result)
  13                 printf("PASS: %s\n", name);
  14         else {
  15                 printf("FAIL: %s\n", name);
  16                 ++fails;
  17         }
  18 }
  19
  20 void test_cmps(void *mem)
  21 {
  22         unsigned char *m1 = mem, *m2 = mem + 1024;
  23         unsigned char m3[1024];
  24         void *rsi, *rdi;
  25         long rcx, tmp;
  26
  27         for (int i = 0; i < 100; ++i)
  28                 m1[i] = m2[i] = m3[i] = i;
  29         for (int i = 100; i < 200; ++i)
  30                 m1[i] = (m3[i] = m2[i] = i) + 1;
  31
  32         rsi = m1; rdi = m3; rcx = 30;
  33         asm volatile("xor %[tmp], %[tmp] \n\t"
  34                      "repe/cmpsb"
  35                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  36                      : : "cc");
  37         report("repe/cmpsb (1)", rcx == 0 && rsi == m1 + 30 && rdi == m3 + 30);
  38
  39         rsi = m1; rdi = m3; rcx = 15;
  40         asm volatile("xor %[tmp], %[tmp] \n\t"
  41                      "repe/cmpsw"
  42                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  43                      : : "cc");
  44         report("repe/cmpsw (1)", rcx == 0 && rsi == m1 + 30 && rdi == m3 + 30);
  45
  46         rsi = m1; rdi = m3; rcx = 7;
  47         asm volatile("xor %[tmp], %[tmp] \n\t"
  48                      "repe/cmpsl"
  49                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  50                      : : "cc");
  51         report("repe/cmpll (1)", rcx == 0 && rsi == m1 + 28 && rdi == m3 + 28);
  52
  53         rsi = m1; rdi = m3; rcx = 4;
  54         asm volatile("xor %[tmp], %[tmp] \n\t"
  55                      "repe/cmpsq"
  56                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  57                      : : "cc");
  58         report("repe/cmpsq (1)", rcx == 0 && rsi == m1 + 32 && rdi == m3 + 32);
  59
  60         rsi = m1; rdi = m3; rcx = 130;
  61         asm volatile("xor %[tmp], %[tmp] \n\t"
  62                      "repe/cmpsb"
  63                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  64                      : : "cc");
  65         report("repe/cmpsb (2)",
  66                rcx == 29 && rsi == m1 + 101 && rdi == m3 + 101);
  67
  68         rsi = m1; rdi = m3; rcx = 65;
  69         asm volatile("xor %[tmp], %[tmp] \n\t"
  70                      "repe/cmpsw"
  71                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  72                      : : "cc");
  73         report("repe/cmpsw (2)",
  74                rcx == 14 && rsi == m1 + 102 && rdi == m3 + 102);
  75
  76         rsi = m1; rdi = m3; rcx = 32;
  77         asm volatile("xor %[tmp], %[tmp] \n\t"
  78                      "repe/cmpsl"
  79                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  80                      : : "cc");
  81         report("repe/cmpll (2)",
  82                rcx == 6 && rsi == m1 + 104 && rdi == m3 + 104);
  83
  84         rsi = m1; rdi = m3; rcx = 16;
  85         asm volatile("xor %[tmp], %[tmp] \n\t"
  86                      "repe/cmpsq"
  87                      : "+S"(rsi), "+D"(rdi), "+c"(rcx), [tmp]"=&r"(tmp)
  88                      : : "cc");
  89         report("repe/cmpsq (2)",
  90                rcx == 3 && rsi == m1 + 104 && rdi == m3 + 104);
  91
  92 }
  93
  94 void test_cr8(void)
  95 {
  96         unsigned long src, dst;
  97
  98         dst = 777;
  99         src = 3;
 100         asm volatile("mov %[src], %%cr8; mov %%cr8, %[dst]"
 101                      : [dst]"+r"(dst), [src]"+r"(src));
 102         report("mov %cr8", dst == 3 && src == 3);
 103 }
 104
 105 void test_push(void *mem)
 106 {
 107         unsigned long tmp;
 108         unsigned long *stack_top = mem + 4096;
 109         unsigned long *new_stack_top;
 110         unsigned long memw = 0x123456789abcdeful;
 111
 112         memset(mem, 0x55, (void *)stack_top - mem);
 113
 114         asm volatile("mov %%rsp, %[tmp] \n\t"
 115                      "mov %[stack_top], %%rsp \n\t"
 116                      "pushq $-7 \n\t"
 117                      "pushq %[reg] \n\t"
 118                      "pushq (%[mem]) \n\t"
 119                      "pushq $-7070707 \n\t"
 120                      "mov %%rsp, %[new_stack_top] \n\t"
 121                      "mov %[tmp], %%rsp"
 122                      : [tmp]"=&r"(tmp), [new_stack_top]"=r"(new_stack_top)
 123                      : [stack_top]"r"(stack_top),
 124                        [reg]"r"(-17l), [mem]"r"(&memw)
 125                      : "memory");
 126
 127         report("push $imm8", stack_top[-1] == -7ul);
 128         report("push %reg", stack_top[-2] == -17ul);
 129         report("push mem", stack_top[-3] == 0x123456789abcdeful);
 130         report("push $imm", stack_top[-4] == -7070707);
 131 }
 132
 133 void test_pop(void *mem)
 134 {
 135         unsigned long tmp;
 136         unsigned long *stack_top = mem + 4096;
 137         unsigned long *new_stack_top;
 138         unsigned long memw = 0x123456789abcdeful;
 139         static unsigned long tmp2;
 140
 141         memset(mem, 0x55, (void *)stack_top - mem);
 142
 143         asm volatile("pushq %[val] \n\t"
 144                      "popq (%[mem])"
 145                      : : [val]"m"(memw), [mem]"r"(mem) : "memory");
 146         report("pop mem", *(unsigned long *)mem == memw);
 147
 148         memw = 7 - memw;
 149         asm volatile("mov %%rsp, %[tmp] \n\t"
 150                      "mov %[stack_top], %%rsp \n\t"
 151                      "pushq %[val] \n\t"
 152                      "popq %[tmp2] \n\t"
 153                      "mov %[tmp], %%rsp"
 154                      : [tmp]"=&r"(tmp), [tmp2]"=m"(tmp2)
 155                      : [val]"r"(memw), [stack_top]"r"(stack_top)
 156                      : "memory");
 157         report("pop mem (2)", tmp2 == memw);
 158
 159 }
 160
 161 unsigned long read_cr0(void)
 162 {
 163         unsigned long cr0;
 164
 165         asm volatile ("mov %%cr0, %0" : "=r"(cr0));
 166         return cr0;
 167 }
 168
 169 void test_smsw(void)
 170 {
 171         char mem[16];
 172         unsigned short msw, msw_orig, *pmsw;
 173         int i, zero;
 174
 175         msw_orig = read_cr0();
 176
 177         asm("smsw %0" : "=r"(msw));
 178         report("smsw (1)", msw == msw_orig);
 179
 180         memset(mem, 0, 16);
 181         pmsw = (void *)mem;
 182         asm("smsw %0" : "=m"(pmsw[4]));
 183         zero = 1;
 184         for (i = 0; i < 8; ++i)
 185                 if (i != 4 && pmsw[i])
 186                         zero = 0;
 187         report("smsw (2)", msw == pmsw[4] && zero);
 188 }
 189
 190 void test_lmsw(void)
 191 {
 192         char mem[16];
 193         unsigned short msw, *pmsw;
 194         unsigned long cr0;
 195
 196         cr0 = read_cr0();
 197
 198         msw = cr0 ^ 8;
 199         asm("lmsw %0" : : "r"(msw));
 200         printf("before %lx after %lx\n", cr0, read_cr0());
 201         report("lmsw (1)", (cr0 ^ read_cr0()) == 8);
 202
 203         pmsw = (void *)mem;
 204         *pmsw = cr0;
 205         asm("lmsw %0" : : "m"(*pmsw));
 206         printf("before %lx after %lx\n", cr0, read_cr0());
 207         report("lmsw (2)", cr0 == read_cr0());
 208 }
 209
 210 int main()
 211 {
 212         void *mem;
 213         unsigned long t1, t2;
 214
 215         setup_vm();
 216         mem = vmap(IORAM_BASE_PHYS, IORAM_LEN);
 217
 218         // test mov reg, r/m and mov r/m, reg
 219         t1 = 0x123456789abcdef;
 220         asm volatile("mov %[t1], (%[mem]) \n\t"
 221                      "mov (%[mem]), %[t2]"
 222                      : [t2]"=r"(t2)
 223                      : [t1]"r"(t1), [mem]"r"(mem)
 224                      : "memory");
 225         report("mov reg, r/m (1)", t2 == 0x123456789abcdef);
 226
 227         test_cmps(mem);
 228
 229         test_push(mem);
 230         test_pop(mem);
 231
 232         test_cr8();
 233
 234         test_smsw();
 235         test_lmsw();
 236
 237         printf("\nSUMMARY: %d tests, %d failures\n", tests, fails);
 238         return fails ? 1 : 0;
 239 }