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 memw = 0x123456789abcdeful;
 138         static unsigned long tmp2;
 139
 140         memset(mem, 0x55, (void *)stack_top - mem);
 141
 142         asm volatile("pushq %[val] \n\t"
 143                      "popq (%[mem])"
 144                      : : [val]"m"(memw), [mem]"r"(mem) : "memory");
 145         report("pop mem", *(unsigned long *)mem == memw);
 146
 147         memw = 7 - memw;
 148         asm volatile("mov %%rsp, %[tmp] \n\t"
 149                      "mov %[stack_top], %%rsp \n\t"
 150                      "pushq %[val] \n\t"
 151                      "popq %[tmp2] \n\t"
 152                      "mov %[tmp], %%rsp"
 153                      : [tmp]"=&r"(tmp), [tmp2]"=m"(tmp2)
 154                      : [val]"r"(memw), [stack_top]"r"(stack_top)
 155                      : "memory");
 156         report("pop mem (2)", tmp2 == memw);
 157
 158         memw = 129443 - memw;
 159         asm volatile("mov %%rsp, %[tmp] \n\t"
 160                      "mov %[stack_top], %%rsp \n\t"
 161                      "pushq %[val] \n\t"
 162                      "popq %[tmp2] \n\t"
 163                      "mov %[tmp], %%rsp"
 164                      : [tmp]"=&r"(tmp), [tmp2]"=r"(tmp2)
 165                      : [val]"r"(memw), [stack_top]"r"(stack_top)
 166                      : "memory");
 167         report("pop reg", tmp2 == memw);
 168
 169         asm volatile("mov %%rsp, %[tmp] \n\t"
 170                      "mov %[stack_top], %%rsp \n\t"
 171                      "push $1f \n\t"
 172                      "ret \n\t"
 173                      "2: jmp 2b \n\t"
 174                      "1: mov %[tmp], %%rsp"
 175                      : [tmp]"=&r"(tmp) : [stack_top]"r"(stack_top)
 176                      : "memory");
 177         report("ret", 1);
 178 }
 179
 180 unsigned long read_cr0(void)
 181 {
 182         unsigned long cr0;
 183
 184         asm volatile ("mov %%cr0, %0" : "=r"(cr0));
 185         return cr0;
 186 }
 187
 188 void test_smsw(void)
 189 {
 190         char mem[16];
 191         unsigned short msw, msw_orig, *pmsw;
 192         int i, zero;
 193
 194         msw_orig = read_cr0();
 195
 196         asm("smsw %0" : "=r"(msw));
 197         report("smsw (1)", msw == msw_orig);
 198
 199         memset(mem, 0, 16);
 200         pmsw = (void *)mem;
 201         asm("smsw %0" : "=m"(pmsw[4]));
 202         zero = 1;
 203         for (i = 0; i < 8; ++i)
 204                 if (i != 4 && pmsw[i])
 205                         zero = 0;
 206         report("smsw (2)", msw == pmsw[4] && zero);
 207 }
 208
 209 void test_lmsw(void)
 210 {
 211         char mem[16];
 212         unsigned short msw, *pmsw;
 213         unsigned long cr0;
 214
 215         cr0 = read_cr0();
 216
 217         msw = cr0 ^ 8;
 218         asm("lmsw %0" : : "r"(msw));
 219         printf("before %lx after %lx\n", cr0, read_cr0());
 220         report("lmsw (1)", (cr0 ^ read_cr0()) == 8);
 221
 222         pmsw = (void *)mem;
 223         *pmsw = cr0;
 224         asm("lmsw %0" : : "m"(*pmsw));
 225         printf("before %lx after %lx\n", cr0, read_cr0());
 226         report("lmsw (2)", cr0 == read_cr0());
 227 }
 228
 229 int main()
 230 {
 231         void *mem;
 232         unsigned long t1, t2;
 233
 234         setup_vm();
 235         mem = vmap(IORAM_BASE_PHYS, IORAM_LEN);
 236
 237         // test mov reg, r/m and mov r/m, reg
 238         t1 = 0x123456789abcdef;
 239         asm volatile("mov %[t1], (%[mem]) \n\t"
 240                      "mov (%[mem]), %[t2]"
 241                      : [t2]"=r"(t2)
 242                      : [t1]"r"(t1), [mem]"r"(mem)
 243                      : "memory");
 244         report("mov reg, r/m (1)", t2 == 0x123456789abcdef);
 245
 246         test_cmps(mem);
 247
 248         test_push(mem);
 249         test_pop(mem);
 250
 251         test_cr8();
 252
 253         test_smsw();
 254         test_lmsw();
 255
 256         printf("\nSUMMARY: %d tests, %d failures\n", tests, fails);
 257         return fails ? 1 : 0;
 258 }