?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mscoree: Update Wine Mono to 9.2.0.
[wine.git] / dlls / ntoskrnl.exe / instr.c
blobabdd9349dcd72b26f687c1386afc5eea7b5b6ad8
1 /*
2 * Emulation of privileged instructions
3 *
4 * Copyright 1995 Alexandre Julliard
5 * Copyright 2005 Ivan Leo Puoti
6 * Copyright 2005 Laurent Pinchart
7 * Copyright 2014-2015 Sebastian Lackner
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include <stdarg.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winternl.h"
29 #define WIN32_NO_STATUS
30 #include "ddk/wdm.h"
31 #include "excpt.h"
32 #include "wine/debug.h"
33
34 #define KSHARED_USER_DATA_PAGE_SIZE 0x1000
35
36 #define CR0_PE 0x00000001 /* Protected Mode */
37 #define CR0_ET 0x00000010 /* Extension Type */
38 #define CR0_NE 0x00000020 /* Numeric Error */
39 #define CR0_WP 0x00010000 /* Write Protect */
40 #define CR0_AM 0x00040000 /* Alignment Mask */
41 #define CR0_PG 0x80000000 /* Paging */
42
43 enum instr_op
44 {
45 INSTR_OP_MOV,
46 INSTR_OP_OR,
47 INSTR_OP_XOR,
48 };
49
50 #ifdef __i386__
51
52 WINE_DEFAULT_DEBUG_CHANNEL(int);
53
54 #include "pshpack1.h"
55 struct idtr
56 {
57 WORD limit;
58 BYTE *base;
59 };
60 #include "poppack.h"
61
62 static LDT_ENTRY idt[256];
63
64 static inline struct idtr get_idtr(void)
65 {
66 struct idtr ret;
67 #ifdef __GNUC__
68 __asm__( "sidtl %0" : "=m" (ret) );
69 #else
70 ret.base = (BYTE *)idt;
71 ret.limit = sizeof(idt) - 1;
72 #endif
73 return ret;
74 }
75
76 /* store an operand into a register */
77 static void store_reg_word( CONTEXT *context, BYTE regmodrm, const BYTE *addr, int long_op )
78 {
79 switch((regmodrm >> 3) & 7)
80 {
81 case 0:
82 if (long_op) context->Eax = *(const DWORD *)addr;
83 else context->Eax = (context->Eax & 0xffff0000) | *(const WORD *)addr;
84 break;
85 case 1:
86 if (long_op) context->Ecx = *(const DWORD *)addr;
87 else context->Ecx = (context->Ecx & 0xffff0000) | *(const WORD *)addr;
88 break;
89 case 2:
90 if (long_op) context->Edx = *(const DWORD *)addr;
91 else context->Edx = (context->Edx & 0xffff0000) | *(const WORD *)addr;
92 break;
93 case 3:
94 if (long_op) context->Ebx = *(const DWORD *)addr;
95 else context->Ebx = (context->Ebx & 0xffff0000) | *(const WORD *)addr;
96 break;
97 case 4:
98 if (long_op) context->Esp = *(const DWORD *)addr;
99 else context->Esp = (context->Esp & 0xffff0000) | *(const WORD *)addr;
100 break;
101 case 5:
102 if (long_op) context->Ebp = *(const DWORD *)addr;
103 else context->Ebp = (context->Ebp & 0xffff0000) | *(const WORD *)addr;
104 break;
105 case 6:
106 if (long_op) context->Esi = *(const DWORD *)addr;
107 else context->Esi = (context->Esi & 0xffff0000) | *(const WORD *)addr;
108 break;
109 case 7:
110 if (long_op) context->Edi = *(const DWORD *)addr;
111 else context->Edi = (context->Edi & 0xffff0000) | *(const WORD *)addr;
112 break;
113 }
114 }
115
116 /* store an operand into a byte register */
117 static void store_reg_byte( CONTEXT *context, BYTE regmodrm, const BYTE *addr )
118 {
119 switch((regmodrm >> 3) & 7)
120 {
121 case 0: context->Eax = (context->Eax & 0xffffff00) | *addr; break;
122 case 1: context->Ecx = (context->Ecx & 0xffffff00) | *addr; break;
123 case 2: context->Edx = (context->Edx & 0xffffff00) | *addr; break;
124 case 3: context->Ebx = (context->Ebx & 0xffffff00) | *addr; break;
125 case 4: context->Eax = (context->Eax & 0xffff00ff) | (*addr << 8); break;
126 case 5: context->Ecx = (context->Ecx & 0xffff00ff) | (*addr << 8); break;
127 case 6: context->Edx = (context->Edx & 0xffff00ff) | (*addr << 8); break;
128 case 7: context->Ebx = (context->Ebx & 0xffff00ff) | (*addr << 8); break;
129 }
130 }
131
132 static DWORD *get_reg_address( CONTEXT *context, BYTE rm )
133 {
134 switch (rm & 7)
135 {
136 case 0: return &context->Eax;
137 case 1: return &context->Ecx;
138 case 2: return &context->Edx;
139 case 3: return &context->Ebx;
140 case 4: return &context->Esp;
141 case 5: return &context->Ebp;
142 case 6: return &context->Esi;
143 case 7: return &context->Edi;
144 }
145 return NULL;
146 }
147
148
149 /***********************************************************************
150 * INSTR_GetOperandAddr
151 *
152 * Return the address of an instruction operand (from the mod/rm byte).
153 */
154 static void *INSTR_GetOperandAddr( CONTEXT *context, BYTE *instr,
155 int long_addr, int segprefix, int *len )
156 {
157 int mod, rm, base = 0, index = 0, ss = 0, off;
158
159 #define GET_VAL(val,type) \
160 { *val = *(type *)instr; instr += sizeof(type); *len += sizeof(type); }
161
162 *len = 0;
163 GET_VAL( &mod, BYTE );
164 rm = mod & 7;
165 mod >>= 6;
166
167 if (mod == 3) return get_reg_address( context, rm );
168
169 if (long_addr)
170 {
171 if (rm == 4)
172 {
173 BYTE sib;
174 GET_VAL( &sib, BYTE );
175 rm = sib & 7;
176 ss = sib >> 6;
177 switch((sib >> 3) & 7)
178 {
179 case 0: index = context->Eax; break;
180 case 1: index = context->Ecx; break;
181 case 2: index = context->Edx; break;
182 case 3: index = context->Ebx; break;
183 case 4: index = 0; break;
184 case 5: index = context->Ebp; break;
185 case 6: index = context->Esi; break;
186 case 7: index = context->Edi; break;
187 }
188 }
189
190 switch(rm)
191 {
192 case 0: base = context->Eax; break;
193 case 1: base = context->Ecx; break;
194 case 2: base = context->Edx; break;
195 case 3: base = context->Ebx; break;
196 case 4: base = context->Esp; break;
197 case 5: base = context->Ebp; break;
198 case 6: base = context->Esi; break;
199 case 7: base = context->Edi; break;
200 }
201 switch (mod)
202 {
203 case 0:
204 if (rm == 5) /* special case: ds:(disp32) */
205 {
206 GET_VAL( &base, DWORD );
207 }
208 break;
209
210 case 1: /* 8-bit disp */
211 GET_VAL( &off, BYTE );
212 base += (signed char)off;
213 break;
214
215 case 2: /* 32-bit disp */
216 GET_VAL( &off, DWORD );
217 base += (signed long)off;
218 break;
219 }
220 }
221 else /* short address */
222 {
223 switch(rm)
224 {
225 case 0: /* ds:(bx,si) */
226 base = LOWORD(context->Ebx) + LOWORD(context->Esi);
227 break;
228 case 1: /* ds:(bx,di) */
229 base = LOWORD(context->Ebx) + LOWORD(context->Edi);
230 break;
231 case 2: /* ss:(bp,si) */
232 base = LOWORD(context->Ebp) + LOWORD(context->Esi);
233 break;
234 case 3: /* ss:(bp,di) */
235 base = LOWORD(context->Ebp) + LOWORD(context->Edi);
236 break;
237 case 4: /* ds:(si) */
238 base = LOWORD(context->Esi);
239 break;
240 case 5: /* ds:(di) */
241 base = LOWORD(context->Edi);
242 break;
243 case 6: /* ss:(bp) */
244 base = LOWORD(context->Ebp);
245 break;
246 case 7: /* ds:(bx) */
247 base = LOWORD(context->Ebx);
248 break;
249 }
250
251 switch(mod)
252 {
253 case 0:
254 if (rm == 6) /* special case: ds:(disp16) */
255 {
256 GET_VAL( &base, WORD );
257 }
258 break;
259
260 case 1: /* 8-bit disp */
261 GET_VAL( &off, BYTE );
262 base += (signed char)off;
263 break;
264
265 case 2: /* 16-bit disp */
266 GET_VAL( &off, WORD );
267 base += (signed short)off;
268 break;
269 }
270 base &= 0xffff;
271 }
272 /* FIXME: we assume that all segments have a base of 0 */
273 return (void *)(base + (index << ss));
274 #undef GET_VAL
275 }
276
277
278 /***********************************************************************
279 * emulate_instruction
280 *
281 * Emulate a privileged instruction.
282 * Returns exception continuation status.
283 */
284 static DWORD emulate_instruction( EXCEPTION_RECORD *rec, CONTEXT *context )
285 {
286 static const char *reg_names[8] = { "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" };
287 int prefix, segprefix, prefixlen, len, long_op, long_addr;
288 BYTE *instr;
289
290 long_op = long_addr = 1;
291 instr = (BYTE *)context->Eip;
292 if (!instr) return ExceptionContinueSearch;
293
294 /* First handle any possible prefix */
295
296 segprefix = -1; /* no prefix */
297 prefix = 1;
298 prefixlen = 0;
299 while(prefix)
300 {
301 switch(*instr)
302 {
303 case 0x2e:
304 segprefix = context->SegCs;
305 break;
306 case 0x36:
307 segprefix = context->SegSs;
308 break;
309 case 0x3e:
310 segprefix = context->SegDs;
311 break;
312 case 0x26:
313 segprefix = context->SegEs;
314 break;
315 case 0x64:
316 segprefix = context->SegFs;
317 break;
318 case 0x65:
319 segprefix = context->SegGs;
320 break;
321 case 0x66:
322 long_op = !long_op; /* opcode size prefix */
323 break;
324 case 0x67:
325 long_addr = !long_addr; /* addr size prefix */
326 break;
327 case 0xf0: /* lock */
328 break;
329 case 0xf2: /* repne */
330 break;
331 case 0xf3: /* repe */
332 break;
333 default:
334 prefix = 0; /* no more prefixes */
335 break;
336 }
337 if (prefix)
338 {
339 instr++;
340 prefixlen++;
341 }
342 }
343
344 /* Now look at the actual instruction */
345
346 switch(*instr)
347 {
348 case 0x0f: /* extended instruction */
349 switch(instr[1])
350 {
351 case 0x20: /* mov crX, Rd */
352 {
353 int reg = (instr[2] >> 3) & 7;
354 DWORD *data = get_reg_address( context, instr[2] );
355 TRACE( "mov cr%u,%s at 0x%08lx\n", reg, reg_names[instr[2] & 7], context->Eip );
356 switch (reg)
357 {
358 case 0: *data = CR0_PE|CR0_ET|CR0_NE|CR0_WP|CR0_AM|CR0_PG; break;
359 case 2: *data = 0; break;
360 case 3: *data = 0; break;
361 case 4: *data = 0; break;
362 default: return ExceptionContinueSearch;
363 }
364 context->Eip += prefixlen + 3;
365 return ExceptionContinueExecution;
366 }
367 case 0x21: /* mov drX, Rd */
368 {
369 int reg = (instr[2] >> 3) & 7;
370 DWORD *data = get_reg_address( context, instr[2] );
371 TRACE( "mov dr%u,%s at 0x%08lx\n", reg, reg_names[instr[2] & 7], context->Eip );
372 switch (reg)
373 {
374 case 0: *data = context->Dr0; break;
375 case 1: *data = context->Dr1; break;
376 case 2: *data = context->Dr2; break;
377 case 3: *data = context->Dr3; break;
378 case 6: *data = context->Dr6; break;
379 case 7: *data = 0x400; break;
380 default: return ExceptionContinueSearch;
381 }
382 context->Eip += prefixlen + 3;
383 return ExceptionContinueExecution;
384 }
385 case 0x22: /* mov Rd, crX */
386 {
387 int reg = (instr[2] >> 3) & 7;
388 DWORD *data = get_reg_address( context, instr[2] );
389 TRACE( "mov %s,cr%u at 0x%08lx, %s=%08lx\n", reg_names[instr[2] & 7],
390 reg, context->Eip, reg_names[instr[2] & 7], *data );
391 switch (reg)
392 {
393 case 0: break;
394 case 2: break;
395 case 3: break;
396 case 4: break;
397 default: return ExceptionContinueSearch;
398 }
399 context->Eip += prefixlen + 3;
400 return ExceptionContinueExecution;
401 }
402 case 0x23: /* mov Rd, drX */
403 {
404 int reg = (instr[2] >> 3) & 7;
405 DWORD *data = get_reg_address( context, instr[2] );
406 TRACE( "mov %s,dr%u at 0x%08lx %s=%08lx\n", reg_names[instr[2] & 7],
407 reg, context->Eip, reg_names[instr[2] & 7], *data );
408 switch (reg)
409 {
410 case 0: context->Dr0 = *data; break;
411 case 1: context->Dr1 = *data; break;
412 case 2: context->Dr2 = *data; break;
413 case 3: context->Dr3 = *data; break;
414 case 6: context->Dr6 = *data; break;
415 case 7: context->Dr7 = *data; break;
416 default: return ExceptionContinueSearch;
417 }
418 context->Eip += prefixlen + 3;
419 return ExceptionContinueExecution;
420 }
421 }
422 break;
423
424 case 0x8a: /* mov Eb, Gb */
425 case 0x8b: /* mov Ev, Gv */
426 {
427 BYTE *data = INSTR_GetOperandAddr(context, instr + 1, long_addr,
428 segprefix, &len);
429 unsigned int data_size = (*instr == 0x8b) ? (long_op ? 4 : 2) : 1;
430 struct idtr idtr = get_idtr();
431 unsigned int offset = data - idtr.base;
432
433 if (offset <= idtr.limit + 1 - data_size)
434 {
435 idt[1].LimitLow = 0x100; /* FIXME */
436 idt[2].LimitLow = 0x11E; /* FIXME */
437 idt[3].LimitLow = 0x500; /* FIXME */
438
439 switch (*instr)
440 {
441 case 0x8a: store_reg_byte( context, instr[1], (BYTE *)idt + offset ); break;
442 case 0x8b: store_reg_word( context, instr[1], (BYTE *)idt + offset, long_op ); break;
443 }
444 context->Eip += prefixlen + len + 1;
445 return ExceptionContinueExecution;
446 }
447 break; /* Unable to emulate it */
448 }
449
450 case 0xfa: /* cli */
451 case 0xfb: /* sti */
452 context->Eip += prefixlen + 1;
453 return ExceptionContinueExecution;
454 }
455 return ExceptionContinueSearch; /* Unable to emulate it */
456 }
457
458
459 /***********************************************************************
460 * vectored_handler
461 *
462 * Vectored exception handler used to emulate protected instructions
463 * from 32-bit code.
464 */
465 LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs )
466 {
467 EXCEPTION_RECORD *record = ptrs->ExceptionRecord;
468 CONTEXT *context = ptrs->ContextRecord;
469
470 if ((record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
471 record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION))
472 {
473 if (emulate_instruction( record, context ) == ExceptionContinueExecution)
474 return EXCEPTION_CONTINUE_EXECUTION;
475 }
476 return EXCEPTION_CONTINUE_SEARCH;
477 }
478
479 #elif defined(__x86_64__) /* __i386__ */
480
481 WINE_DEFAULT_DEBUG_CHANNEL(int);
482
483 #define REX_B 1
484 #define REX_X 2
485 #define REX_R 4
486 #define REX_W 8
487
488 #define MSR_LSTAR 0xc0000082
489
490 #define REGMODRM_MOD( regmodrm, rex ) ((regmodrm) >> 6)
491 #define REGMODRM_REG( regmodrm, rex ) (((regmodrm) >> 3) & 7) | (((rex) & REX_R) ? 8 : 0)
492 #define REGMODRM_RM( regmodrm, rex ) (((regmodrm) & 7) | (((rex) & REX_B) ? 8 : 0))
493
494 #define SIB_SS( sib, rex ) ((sib) >> 6)
495 #define SIB_INDEX( sib, rex ) (((sib) >> 3) & 7) | (((rex) & REX_X) ? 8 : 0)
496 #define SIB_BASE( sib, rex ) (((sib) & 7) | (((rex) & REX_B) ? 8 : 0))
497
498 /* keep in sync with dlls/ntdll/thread.c:thread_init */
499 static const BYTE *wine_user_shared_data = (BYTE *)0x7ffe0000;
500 static const BYTE *user_shared_data = (BYTE *)0xfffff78000000000;
501
502 static inline DWORD64 *get_int_reg( CONTEXT *context, int index )
503 {
504 return &context->Rax + index; /* index should be in range 0 .. 15 */
505 }
506
507 static inline int get_op_size( int long_op, int rex )
508 {
509 if (rex & REX_W)
510 return sizeof(DWORD64);
511 else if (long_op)
512 return sizeof(DWORD);
513 else
514 return sizeof(WORD);
515 }
516
517 /* store an operand into a register */
518 static void store_reg_word( CONTEXT *context, BYTE regmodrm, const BYTE *addr, int long_op, int rex,
519 enum instr_op op )
520 {
521 int index = REGMODRM_REG( regmodrm, rex );
522 BYTE *reg = (BYTE *)get_int_reg( context, index );
523 int op_size = get_op_size( long_op, rex );
524 int i;
525
526 switch (op)
527 {
528 case INSTR_OP_MOV:
529 memcpy( reg, addr, op_size );
530 break;
531 case INSTR_OP_OR:
532 for (i = 0; i < op_size; ++i)
533 reg[i] |= addr[i];
534 break;
535 case INSTR_OP_XOR:
536 for (i = 0; i < op_size; ++i)
537 reg[i] ^= addr[i];
538 break;
539 }
540 }
541
542 /* store an operand into a byte register */
543 static void store_reg_byte( CONTEXT *context, BYTE regmodrm, const BYTE *addr, int rex, enum instr_op op )
544 {
545 int index = REGMODRM_REG( regmodrm, rex );
546 BYTE *reg = (BYTE *)get_int_reg( context, index );
547 if (!rex && index >= 4 && index < 8) reg -= (4 * sizeof(DWORD64) - 1); /* special case: ah, ch, dh, bh */
548
549 switch (op)
550 {
551 case INSTR_OP_MOV:
552 *reg = *addr;
553 break;
554 case INSTR_OP_OR:
555 *reg |= *addr;
556 break;
557 case INSTR_OP_XOR:
558 *reg ^= *addr;
559 break;
560 }
561 }
562
563 /***********************************************************************
564 * INSTR_GetOperandAddr
565 *
566 * Return the address of an instruction operand (from the mod/rm byte).
567 */
568 static BYTE *INSTR_GetOperandAddr( CONTEXT *context, BYTE *instr, int addl_instr_len,
569 int long_addr, int rex, int segprefix, int *len )
570 {
571 int mod, rm, ss = 0, off, have_sib = 0;
572 DWORD64 base = 0, index = 0;
573
574 #define GET_VAL( val, type ) \
575 { *val = *(type *)instr; instr += sizeof(type); *len += sizeof(type); }
576
577 *len = 0;
578 GET_VAL( &mod, BYTE );
579 rm = REGMODRM_RM( mod, rex );
580 mod = REGMODRM_MOD( mod, rex );
581
582 if (mod == 3)
583 return (BYTE *)get_int_reg( context, rm );
584
585 if ((rm & 7) == 4)
586 {
587 BYTE sib;
588 int id;
589
590 GET_VAL( &sib, BYTE );
591 rm = SIB_BASE( sib, rex );
592 id = SIB_INDEX( sib, rex );
593 ss = SIB_SS( sib, rex );
594
595 index = (id != 4) ? *get_int_reg( context, id ) : 0;
596 if (!long_addr) index &= 0xffffffff;
597 have_sib = 1;
598 }
599
600 base = *get_int_reg( context, rm );
601 if (!long_addr) base &= 0xffffffff;
602
603 switch (mod)
604 {
605 case 0:
606 if (rm == 5) /* special case */
607 {
608 base = have_sib ? 0 : context->Rip;
609 if (!long_addr) base &= 0xffffffff;
610 GET_VAL( &off, DWORD );
611 base += (signed long)off;
612 base += (signed long)*len + (signed long)addl_instr_len;
613 }
614 break;
615
616 case 1: /* 8-bit disp */
617 GET_VAL( &off, BYTE );
618 base += (signed char)off;
619 break;
620
621 case 2: /* 32-bit disp */
622 GET_VAL( &off, DWORD );
623 base += (signed long)off;
624 break;
625 }
626
627 /* FIXME: we assume that all segments have a base of 0 */
628 return (BYTE *)(base + (index << ss));
629 #undef GET_VAL
630 }
631
632
633 static void fake_syscall_function(void)
634 {
635 TRACE("() stub\n");
636 }
637
638
639 /***********************************************************************
640 * emulate_instruction
641 *
642 * Emulate a privileged instruction.
643 * Returns exception continuation status.
644 */
645 static DWORD emulate_instruction( EXCEPTION_RECORD *rec, CONTEXT *context )
646 {
647 static const char *reg_names[16] = { "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
648 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" };
649 int prefix, segprefix, prefixlen, len, long_op, long_addr, rex;
650 BYTE *instr;
651
652 long_op = long_addr = 1;
653 instr = (BYTE *)context->Rip;
654 if (!instr) return ExceptionContinueSearch;
655
656 /* First handle any possible prefix */
657
658 segprefix = -1; /* no seg prefix */
659 rex = 0; /* no rex prefix */
660 prefix = 1;
661 prefixlen = 0;
662 while(prefix)
663 {
664 switch(*instr)
665 {
666 case 0x2e:
667 segprefix = context->SegCs;
668 break;
669 case 0x36:
670 segprefix = context->SegSs;
671 break;
672 case 0x3e:
673 segprefix = context->SegDs;
674 break;
675 case 0x26:
676 segprefix = context->SegEs;
677 break;
678 case 0x64:
679 segprefix = context->SegFs;
680 break;
681 case 0x65:
682 segprefix = context->SegGs;
683 break;
684 case 0x66:
685 long_op = !long_op; /* opcode size prefix */
686 break;
687 case 0x67:
688 long_addr = !long_addr; /* addr size prefix */
689 break;
690 case 0x40: /* rex */
691 case 0x41:
692 case 0x42:
693 case 0x43:
694 case 0x44:
695 case 0x45:
696 case 0x46:
697 case 0x47:
698 case 0x48:
699 case 0x49:
700 case 0x4a:
701 case 0x4b:
702 case 0x4c:
703 case 0x4d:
704 case 0x4e:
705 case 0x4f:
706 rex = *instr;
707 break;
708 case 0xf0: /* lock */
709 break;
710 case 0xf2: /* repne */
711 break;
712 case 0xf3: /* repe */
713 break;
714 default:
715 prefix = 0; /* no more prefixes */
716 break;
717 }
718 if (prefix)
719 {
720 instr++;
721 prefixlen++;
722 }
723 }
724
725 /* Now look at the actual instruction */
726
727 switch(*instr)
728 {
729 case 0x0f: /* extended instruction */
730 switch(instr[1])
731 {
732 case 0x20: /* mov crX, Rd */
733 {
734 int reg = REGMODRM_REG( instr[2], rex );
735 int rm = REGMODRM_RM( instr[2], rex );
736 DWORD64 *data = get_int_reg( context, rm );
737 TRACE( "mov cr%u,%s at %Ix\n", reg, reg_names[rm], context->Rip );
738 switch (reg)
739 {
740 case 0: *data = 0x10; break; /* FIXME: set more bits ? */
741 case 2: *data = 0; break;
742 case 3: *data = 0; break;
743 case 4: *data = 0; break;
744 case 8: *data = 0; break;
745 default: return ExceptionContinueSearch;
746 }
747 context->Rip += prefixlen + 3;
748 return ExceptionContinueExecution;
749 }
750 case 0x21: /* mov drX, Rd */
751 {
752 int reg = REGMODRM_REG( instr[2], rex );
753 int rm = REGMODRM_RM( instr[2], rex );
754 DWORD64 *data = get_int_reg( context, rm );
755 TRACE( "mov dr%u,%s at %Ix\n", reg, reg_names[rm], context->Rip );
756 switch (reg)
757 {
758 case 0: *data = context->Dr0; break;
759 case 1: *data = context->Dr1; break;
760 case 2: *data = context->Dr2; break;
761 case 3: *data = context->Dr3; break;
762 case 4: /* dr4 and dr5 are obsolete aliases for dr6 and dr7 */
763 case 6: *data = context->Dr6; break;
764 case 5:
765 case 7: *data = 0x400; break;
766 default: return ExceptionContinueSearch;
767 }
768 context->Rip += prefixlen + 3;
769 return ExceptionContinueExecution;
770 }
771 case 0x22: /* mov Rd, crX */
772 {
773 int reg = REGMODRM_REG( instr[2], rex );
774 int rm = REGMODRM_RM( instr[2], rex );
775 DWORD64 *data = get_int_reg( context, rm );
776 TRACE( "mov %s,cr%u at %Ix, %s=%Ix\n", reg_names[rm], reg, context->Rip, reg_names[rm], *data );
777 switch (reg)
778 {
779 case 0: break;
780 case 2: break;
781 case 3: break;
782 case 4: break;
783 case 8: break;
784 default: return ExceptionContinueSearch;
785 }
786 context->Rip += prefixlen + 3;
787 return ExceptionContinueExecution;
788 }
789 case 0x23: /* mov Rd, drX */
790 {
791 int reg = REGMODRM_REG( instr[2], rex );
792 int rm = REGMODRM_RM( instr[2], rex );
793 DWORD64 *data = get_int_reg( context, rm );
794 TRACE( "mov %s,dr%u at %Ix, %s=%Ix\n", reg_names[rm], reg, context->Rip, reg_names[rm], *data );
795 switch (reg)
796 {
797 case 0: context->Dr0 = *data; break;
798 case 1: context->Dr1 = *data; break;
799 case 2: context->Dr2 = *data; break;
800 case 3: context->Dr3 = *data; break;
801 case 4: /* dr4 and dr5 are obsolete aliases for dr6 and dr7 */
802 case 6: context->Dr6 = *data; break;
803 case 5:
804 case 7: context->Dr7 = *data; break;
805 default: return ExceptionContinueSearch;
806 }
807 context->Rip += prefixlen + 3;
808 return ExceptionContinueExecution;
809 }
810 case 0x32: /* rdmsr */
811 {
812 ULONG reg = context->Rcx;
813 TRACE("rdmsr CR 0x%08lx\n", reg);
814 switch (reg)
815 {
816 case MSR_LSTAR:
817 {
818 ULONG_PTR syscall_address = (ULONG_PTR)fake_syscall_function;
819 context->Rdx = (ULONG)(syscall_address >> 32);
820 context->Rax = (ULONG)syscall_address;
821 break;
822 }
823 default:
824 FIXME("reg %#lx, returning 0.\n", reg);
825 context->Rdx = 0;
826 context->Rax = 0;
827 break;
828 }
829 context->Rip += prefixlen + 2;
830 return ExceptionContinueExecution;
831 }
832 case 0xb6: /* movzx Eb, Gv */
833 case 0xb7: /* movzx Ew, Gv */
834 {
835 BYTE *data = INSTR_GetOperandAddr( context, instr + 2, prefixlen + 2, long_addr,
836 rex, segprefix, &len );
837 unsigned int data_size = (instr[1] == 0xb7) ? 2 : 1;
838 SIZE_T offset = data - user_shared_data;
839
840 if (offset <= KSHARED_USER_DATA_PAGE_SIZE - data_size)
841 {
842 ULONGLONG temp = 0;
843
844 TRACE("USD offset %#x at %p.\n", (unsigned int)offset, (void *)context->Rip);
845 memcpy( &temp, wine_user_shared_data + offset, data_size );
846 store_reg_word( context, instr[2], (BYTE *)&temp, long_op, rex, INSTR_OP_MOV );
847 context->Rip += prefixlen + len + 2;
848 return ExceptionContinueExecution;
849 }
850 break; /* Unable to emulate it */
851 }
852 }
853 break; /* Unable to emulate it */
854
855 case 0x8a: /* mov Eb, Gb */
856 case 0x8b: /* mov Ev, Gv */
857 case 0x0b: /* or Ev, Gv */
858 case 0x33: /* xor Ev, Gv */
859 {
860 BYTE *data = INSTR_GetOperandAddr( context, instr + 1, prefixlen + 1, long_addr,
861 rex, segprefix, &len );
862 unsigned int data_size = (*instr == 0x8b) ? get_op_size( long_op, rex ) : 1;
863 SIZE_T offset = data - user_shared_data;
864
865 if (offset <= KSHARED_USER_DATA_PAGE_SIZE - data_size)
866 {
867 TRACE("USD offset %#x at %p.\n", (unsigned int)offset, (void *)context->Rip);
868 switch (*instr)
869 {
870 case 0x8a:
871 store_reg_byte( context, instr[1], wine_user_shared_data + offset,
872 rex, INSTR_OP_MOV );
873 break;
874 case 0x8b:
875 store_reg_word( context, instr[1], wine_user_shared_data + offset,
876 long_op, rex, INSTR_OP_MOV );
877 break;
878 case 0x0b:
879 store_reg_word( context, instr[1], wine_user_shared_data + offset,
880 long_op, rex, INSTR_OP_OR );
881 break;
882 case 0x33:
883 store_reg_word( context, instr[1], wine_user_shared_data + offset,
884 long_op, rex, INSTR_OP_XOR );
885 break;
886 }
887 context->Rip += prefixlen + len + 1;
888 return ExceptionContinueExecution;
889 }
890 break; /* Unable to emulate it */
891 }
892
893 case 0xa0: /* mov Ob, AL */
894 case 0xa1: /* mov Ovqp, rAX */
895 {
896 BYTE *data = (BYTE *)(long_addr ? *(DWORD64 *)(instr + 1) : *(DWORD *)(instr + 1));
897 unsigned int data_size = (*instr == 0xa1) ? get_op_size( long_op, rex ) : 1;
898 SIZE_T offset = data - user_shared_data;
899 len = long_addr ? sizeof(DWORD64) : sizeof(DWORD);
900
901 if (offset <= KSHARED_USER_DATA_PAGE_SIZE - data_size)
902 {
903 TRACE("USD offset %#x at %p.\n", (unsigned int)offset, (void *)context->Rip);
904 memcpy( &context->Rax, wine_user_shared_data + offset, data_size );
905 context->Rip += prefixlen + len + 1;
906 return ExceptionContinueExecution;
907 }
908 break; /* Unable to emulate it */
909 }
910
911 case 0xfa: /* cli */
912 case 0xfb: /* sti */
913 context->Rip += prefixlen + 1;
914 return ExceptionContinueExecution;
915 }
916 return ExceptionContinueSearch; /* Unable to emulate it */
917 }
918
919
920 /***********************************************************************
921 * vectored_handler
922 *
923 * Vectored exception handler used to emulate protected instructions
924 * from 64-bit code.
925 */
926 LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs )
927 {
928 EXCEPTION_RECORD *record = ptrs->ExceptionRecord;
929 CONTEXT *context = ptrs->ContextRecord;
930
931 if (record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION ||
932 (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
933 record->ExceptionInformation[0] == EXCEPTION_READ_FAULT))
934 {
935 if (emulate_instruction( record, context ) == ExceptionContinueExecution)
936 {
937 TRACE( "next instruction rip=%Ix\n", context->Rip );
938 TRACE( " rax=%016Ix rbx=%016Ix rcx=%016Ix rdx=%016Ix\n",
939 context->Rax, context->Rbx, context->Rcx, context->Rdx );
940 TRACE( " rsi=%016Ix rdi=%016Ix rbp=%016Ix rsp=%016Ix\n",
941 context->Rsi, context->Rdi, context->Rbp, context->Rsp );
942 TRACE( " r8=%016Ix r9=%016Ix r10=%016Ix r11=%016Ix\n",
943 context->R8, context->R9, context->R10, context->R11 );
944 TRACE( " r12=%016Ix r13=%016Ix r14=%016Ix r15=%016Ix\n",
945 context->R12, context->R13, context->R14, context->R15 );
946
947 return EXCEPTION_CONTINUE_EXECUTION;
948 }
949 }
950 return EXCEPTION_CONTINUE_SEARCH;
951 }
952
953 #endif /* __x86_64__ */
Windows API implementation