?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed HeapRealloc typo.
[wine/wine64.git] / dlls / kernel / instr.c
blob4572e17ed6c37348c67a4d43f2a0c55000febf10
1 /*
2 * Emulation of privileged instructions
3 *
4 * Copyright 1995 Alexandre Julliard
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.1 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
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25
26 #include "ntstatus.h"
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "wine/winuser16.h"
31 #include "excpt.h"
32 #include "module.h"
33 #include "miscemu.h"
34 #include "wine/debug.h"
35 #include "kernel_private.h"
36 #include "thread.h"
37 #include "wine/exception.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(int);
40 WINE_DECLARE_DEBUG_CHANNEL(io);
41
42 /* macros to set parts of a DWORD */
43 #define SET_LOWORD(dw,val) ((dw) = ((dw) & 0xffff0000) | LOWORD(val))
44 #define SET_LOBYTE(dw,val) ((dw) = ((dw) & 0xffffff00) | LOBYTE(val))
45 #define ADD_LOWORD(dw,val) ((dw) = ((dw) & 0xffff0000) | LOWORD((DWORD)(dw)+(val)))
46 #define ISV86(context) ((context)->EFlags & 0x00020000)
47
48 inline static void add_stack( CONTEXT86 *context, int offset )
49 {
50 if (ISV86(context) || !IS_SELECTOR_32BIT(context->SegSs))
51 ADD_LOWORD( context->Esp, offset );
52 else
53 context->Esp += offset;
54 }
55
56 inline static void *make_ptr( CONTEXT86 *context, DWORD seg, DWORD off, int long_addr )
57 {
58 if (ISV86(context)) return (void *)((seg << 4) + LOWORD(off));
59 if (wine_ldt_is_system(seg)) return (void *)off;
60 if (!long_addr) off = LOWORD(off);
61 return (char *) MapSL( MAKESEGPTR( seg, 0 ) ) + off;
62 }
63
64 inline static void *get_stack( CONTEXT86 *context )
65 {
66 if (ISV86(context)) return (void *)((context->SegSs << 4) + LOWORD(context->Esp));
67 return wine_ldt_get_ptr( context->SegSs, context->Esp );
68 }
69
70
71 static void (WINAPI *DOS_EmulateInterruptPM)( CONTEXT86 *context, BYTE intnum );
72 static void (WINAPI *DOS_CallBuiltinHandler)( CONTEXT86 *context, BYTE intnum );
73 static DWORD (WINAPI *DOS_inport)( int port, int size );
74 static void (WINAPI *DOS_outport)( int port, int size, DWORD val );
75
76
77 static void init_winedos(void)
78 {
79 static HMODULE module;
80
81 if (module) return;
82 module = LoadLibraryA( "winedos.dll" );
83 if (!module)
84 {
85 ERR("could not load winedos.dll, DOS subsystem unavailable\n");
86 module = (HMODULE)1; /* don't try again */
87 return;
88 }
89 #define GET_ADDR(func) DOS_##func = (void *)GetProcAddress(module, #func);
90 GET_ADDR(inport);
91 GET_ADDR(outport);
92 GET_ADDR(EmulateInterruptPM);
93 GET_ADDR(CallBuiltinHandler);
94 #undef GET_ADDR
95 }
96
97
98 /***********************************************************************
99 * INSTR_ReplaceSelector
100 *
101 * Try to replace an invalid selector by a valid one.
102 * The only selector where it is allowed to do "mov ax,40;mov es,ax"
103 * is the so called 'bimodal' selector 0x40, which points to the BIOS
104 * data segment. Used by (at least) Borland products (and programs compiled
105 * using Borland products).
106 *
107 * See Undocumented Windows, Chapter 5, __0040.
108 */
109 static BOOL INSTR_ReplaceSelector( CONTEXT86 *context, WORD *sel )
110 {
111 if (*sel == 0x40)
112 {
113 static WORD sys_timer = 0;
114 if (!sys_timer)
115 sys_timer = CreateSystemTimer( 55, DOSMEM_Tick );
116 *sel = DOSMEM_BiosDataSeg;
117 return TRUE;
118 }
119 return FALSE; /* Can't replace selector, crashdump */
120 }
121
122
123 /***********************************************************************
124 * INSTR_GetOperandAddr
125 *
126 * Return the address of an instruction operand (from the mod/rm byte).
127 */
128 static BYTE *INSTR_GetOperandAddr( CONTEXT86 *context, BYTE *instr,
129 int long_addr, int segprefix, int *len )
130 {
131 int mod, rm, base, index = 0, ss = 0, seg = 0, off;
132 LDT_ENTRY entry;
133
134 #define GET_VAL(val,type) \
135 { *val = *(type *)instr; instr += sizeof(type); *len += sizeof(type); }
136
137 *len = 0;
138 GET_VAL( &mod, BYTE );
139 rm = mod & 7;
140 mod >>= 6;
141
142 if (mod == 3)
143 {
144 switch(rm)
145 {
146 case 0: return (BYTE *)&context->Eax;
147 case 1: return (BYTE *)&context->Ecx;
148 case 2: return (BYTE *)&context->Edx;
149 case 3: return (BYTE *)&context->Ebx;
150 case 4: return (BYTE *)&context->Esp;
151 case 5: return (BYTE *)&context->Ebp;
152 case 6: return (BYTE *)&context->Esi;
153 case 7: return (BYTE *)&context->Edi;
154 }
155 }
156
157 if (long_addr)
158 {
159 if (rm == 4)
160 {
161 BYTE sib;
162 GET_VAL( &sib, BYTE );
163 rm = sib & 7;
164 ss = sib >> 6;
165 switch(sib >> 3)
166 {
167 case 0: index = context->Eax; break;
168 case 1: index = context->Ecx; break;
169 case 2: index = context->Edx; break;
170 case 3: index = context->Ebx; break;
171 case 4: index = 0; break;
172 case 5: index = context->Ebp; break;
173 case 6: index = context->Esi; break;
174 case 7: index = context->Edi; break;
175 }
176 }
177
178 switch(rm)
179 {
180 case 0: base = context->Eax; seg = context->SegDs; break;
181 case 1: base = context->Ecx; seg = context->SegDs; break;
182 case 2: base = context->Edx; seg = context->SegDs; break;
183 case 3: base = context->Ebx; seg = context->SegDs; break;
184 case 4: base = context->Esp; seg = context->SegSs; break;
185 case 5: base = context->Ebp; seg = context->SegSs; break;
186 case 6: base = context->Esi; seg = context->SegDs; break;
187 case 7: base = context->Edi; seg = context->SegDs; break;
188 }
189 switch (mod)
190 {
191 case 0:
192 if (rm == 5) /* special case: ds:(disp32) */
193 {
194 GET_VAL( &base, DWORD );
195 seg = context->SegDs;
196 }
197 break;
198
199 case 1: /* 8-bit disp */
200 GET_VAL( &off, BYTE );
201 base += (signed char)off;
202 break;
203
204 case 2: /* 32-bit disp */
205 GET_VAL( &off, DWORD );
206 base += (signed long)off;
207 break;
208 }
209 }
210 else /* short address */
211 {
212 switch(rm)
213 {
214 case 0: /* ds:(bx,si) */
215 base = LOWORD(context->Ebx) + LOWORD(context->Esi);
216 seg = context->SegDs;
217 break;
218 case 1: /* ds:(bx,di) */
219 base = LOWORD(context->Ebx) + LOWORD(context->Edi);
220 seg = context->SegDs;
221 break;
222 case 2: /* ss:(bp,si) */
223 base = LOWORD(context->Ebp) + LOWORD(context->Esi);
224 seg = context->SegSs;
225 break;
226 case 3: /* ss:(bp,di) */
227 base = LOWORD(context->Ebp) + LOWORD(context->Edi);
228 seg = context->SegSs;
229 break;
230 case 4: /* ds:(si) */
231 base = LOWORD(context->Esi);
232 seg = context->SegDs;
233 break;
234 case 5: /* ds:(di) */
235 base = LOWORD(context->Edi);
236 seg = context->SegDs;
237 break;
238 case 6: /* ss:(bp) */
239 base = LOWORD(context->Ebp);
240 seg = context->SegSs;
241 break;
242 case 7: /* ds:(bx) */
243 base = LOWORD(context->Ebx);
244 seg = context->SegDs;
245 break;
246 }
247
248 switch(mod)
249 {
250 case 0:
251 if (rm == 6) /* special case: ds:(disp16) */
252 {
253 GET_VAL( &base, WORD );
254 seg = context->SegDs;
255 }
256 break;
257
258 case 1: /* 8-bit disp */
259 GET_VAL( &off, BYTE );
260 base += (signed char)off;
261 break;
262
263 case 2: /* 16-bit disp */
264 GET_VAL( &off, WORD );
265 base += (signed short)off;
266 break;
267 }
268 base &= 0xffff;
269 }
270 if (segprefix != -1) seg = segprefix;
271
272 /* Make sure the segment and offset are valid */
273 if (wine_ldt_is_system(seg)) return (BYTE *)(base + (index << ss));
274 if ((seg & 7) != 7) return NULL;
275 wine_ldt_get_entry( seg, &entry );
276 if (wine_ldt_is_empty( &entry )) return NULL;
277 if (wine_ldt_get_limit(&entry) < (base + (index << ss))) return NULL;
278 return (char *)wine_ldt_get_base(&entry) + base + (index << ss);
279 #undef GET_VAL
280 }
281
282
283 /***********************************************************************
284 * INSTR_EmulateLDS
285 *
286 * Emulate the LDS (and LES,LFS,etc.) instruction.
287 */
288 static BOOL INSTR_EmulateLDS( CONTEXT86 *context, BYTE *instr, int long_op,
289 int long_addr, int segprefix, int *len )
290 {
291 WORD seg;
292 BYTE *regmodrm = instr + 1 + (*instr == 0x0f);
293 BYTE *addr = INSTR_GetOperandAddr( context, regmodrm,
294 long_addr, segprefix, len );
295 if (!addr)
296 return FALSE; /* Unable to emulate it */
297 seg = *(WORD *)(addr + (long_op ? 4 : 2));
298
299 if (!INSTR_ReplaceSelector( context, &seg ))
300 return FALSE; /* Unable to emulate it */
301
302 /* Now store the offset in the correct register */
303
304 switch((*regmodrm >> 3) & 7)
305 {
306 case 0:
307 if (long_op) context->Eax = *(DWORD *)addr;
308 else SET_LOWORD(context->Eax,*(WORD *)addr);
309 break;
310 case 1:
311 if (long_op) context->Ecx = *(DWORD *)addr;
312 else SET_LOWORD(context->Ecx,*(WORD *)addr);
313 break;
314 case 2:
315 if (long_op) context->Edx = *(DWORD *)addr;
316 else SET_LOWORD(context->Edx,*(WORD *)addr);
317 break;
318 case 3:
319 if (long_op) context->Ebx = *(DWORD *)addr;
320 else SET_LOWORD(context->Ebx,*(WORD *)addr);
321 break;
322 case 4:
323 if (long_op) context->Esp = *(DWORD *)addr;
324 else SET_LOWORD(context->Esp,*(WORD *)addr);
325 break;
326 case 5:
327 if (long_op) context->Ebp = *(DWORD *)addr;
328 else SET_LOWORD(context->Ebp,*(WORD *)addr);
329 break;
330 case 6:
331 if (long_op) context->Esi = *(DWORD *)addr;
332 else SET_LOWORD(context->Esi,*(WORD *)addr);
333 break;
334 case 7:
335 if (long_op) context->Edi = *(DWORD *)addr;
336 else SET_LOWORD(context->Edi,*(WORD *)addr);
337 break;
338 }
339
340 /* Store the correct segment in the segment register */
341
342 switch(*instr)
343 {
344 case 0xc4: context->SegEs = seg; break; /* les */
345 case 0xc5: context->SegDs = seg; break; /* lds */
346 case 0x0f: switch(instr[1])
347 {
348 case 0xb2: context->SegSs = seg; break; /* lss */
349 case 0xb4: context->SegFs = seg; break; /* lfs */
350 case 0xb5: context->SegGs = seg; break; /* lgs */
351 }
352 break;
353 }
354
355 /* Add the opcode size to the total length */
356
357 *len += 1 + (*instr == 0x0f);
358 return TRUE;
359 }
360
361 /***********************************************************************
362 * INSTR_inport
363 *
364 * input on a I/O port
365 */
366 static DWORD INSTR_inport( WORD port, int size, CONTEXT86 *context )
367 {
368 DWORD res = ~0U;
369
370 if (!DOS_inport) init_winedos();
371 if (DOS_inport) res = DOS_inport( port, size );
372
373 if (TRACE_ON(io))
374 {
375 switch(size)
376 {
377 case 1:
378 DPRINTF( "0x%x < %02x @ %04x:%04x\n", port, LOBYTE(res),
379 (WORD)context->SegCs, LOWORD(context->Eip));
380 break;
381 case 2:
382 DPRINTF( "0x%x < %04x @ %04x:%04x\n", port, LOWORD(res),
383 (WORD)context->SegCs, LOWORD(context->Eip));
384 break;
385 case 4:
386 DPRINTF( "0x%x < %08lx @ %04x:%04x\n", port, res,
387 (WORD)context->SegCs, LOWORD(context->Eip));
388 break;
389 }
390 }
391 return res;
392 }
393
394
395 /***********************************************************************
396 * INSTR_outport
397 *
398 * output on a I/O port
399 */
400 static void INSTR_outport( WORD port, int size, DWORD val, CONTEXT86 *context )
401 {
402 if (!DOS_outport) init_winedos();
403 if (DOS_outport) DOS_outport( port, size, val );
404
405 if (TRACE_ON(io))
406 {
407 switch(size)
408 {
409 case 1:
410 DPRINTF("0x%x > %02x @ %04x:%04x\n", port, LOBYTE(val),
411 (WORD)context->SegCs, LOWORD(context->Eip));
412 break;
413 case 2:
414 DPRINTF("0x%x > %04x @ %04x:%04x\n", port, LOWORD(val),
415 (WORD)context->SegCs, LOWORD(context->Eip));
416 break;
417 case 4:
418 DPRINTF("0x%x > %08lx @ %04x:%04x\n", port, val,
419 (WORD)context->SegCs, LOWORD(context->Eip));
420 break;
421 }
422 }
423 }
424
425
426 /***********************************************************************
427 * INSTR_EmulateInstruction
428 *
429 * Emulate a privileged instruction.
430 * Returns exception continuation status.
431 */
432 DWORD INSTR_EmulateInstruction( EXCEPTION_RECORD *rec, CONTEXT86 *context )
433 {
434 int prefix, segprefix, prefixlen, len, repX, long_op, long_addr;
435 BYTE *instr;
436
437 long_op = long_addr = (!ISV86(context) && IS_SELECTOR_32BIT(context->SegCs));
438 instr = make_ptr( context, context->SegCs, context->Eip, TRUE );
439 if (!instr) return ExceptionContinueSearch;
440
441 /* First handle any possible prefix */
442
443 segprefix = -1; /* no prefix */
444 prefix = 1;
445 repX = 0;
446 prefixlen = 0;
447 while(prefix)
448 {
449 switch(*instr)
450 {
451 case 0x2e:
452 segprefix = context->SegCs;
453 break;
454 case 0x36:
455 segprefix = context->SegSs;
456 break;
457 case 0x3e:
458 segprefix = context->SegDs;
459 break;
460 case 0x26:
461 segprefix = context->SegEs;
462 break;
463 case 0x64:
464 segprefix = context->SegFs;
465 break;
466 case 0x65:
467 segprefix = context->SegGs;
468 break;
469 case 0x66:
470 long_op = !long_op; /* opcode size prefix */
471 break;
472 case 0x67:
473 long_addr = !long_addr; /* addr size prefix */
474 break;
475 case 0xf0: /* lock */
476 break;
477 case 0xf2: /* repne */
478 repX = 1;
479 break;
480 case 0xf3: /* repe */
481 repX = 2;
482 break;
483 default:
484 prefix = 0; /* no more prefixes */
485 break;
486 }
487 if (prefix)
488 {
489 instr++;
490 prefixlen++;
491 }
492 }
493
494 /* Now look at the actual instruction */
495
496 switch(*instr)
497 {
498 case 0x07: /* pop es */
499 case 0x17: /* pop ss */
500 case 0x1f: /* pop ds */
501 {
502 WORD seg = *(WORD *)get_stack( context );
503 if (INSTR_ReplaceSelector( context, &seg ))
504 {
505 switch(*instr)
506 {
507 case 0x07: context->SegEs = seg; break;
508 case 0x17: context->SegSs = seg; break;
509 case 0x1f: context->SegDs = seg; break;
510 }
511 add_stack(context, long_op ? 4 : 2);
512 context->Eip += prefixlen + 1;
513 return ExceptionContinueExecution;
514 }
515 }
516 break; /* Unable to emulate it */
517
518 case 0x0f: /* extended instruction */
519 switch(instr[1])
520 {
521 case 0x22: /* mov eax, crX */
522 switch (instr[2])
523 {
524 case 0xc0:
525 ERR("mov eax,cr0 at 0x%08lx, EAX=0x%08lx\n",
526 context->Eip,context->Eax );
527 context->Eip += prefixlen+3;
528 return ExceptionContinueExecution;
529 default:
530 break; /*fallthrough to bad instruction handling */
531 }
532 break; /*fallthrough to bad instruction handling */
533 case 0x20: /* mov crX, eax */
534 switch (instr[2])
535 {
536 case 0xe0: /* mov cr4, eax */
537 /* CR4 register . See linux/arch/i386/mm/init.c, X86_CR4_ defs
538 * bit 0: VME Virtual Mode Exception ?
539 * bit 1: PVI Protected mode Virtual Interrupt
540 * bit 2: TSD Timestamp disable
541 * bit 3: DE Debugging extensions
542 * bit 4: PSE Page size extensions
543 * bit 5: PAE Physical address extension
544 * bit 6: MCE Machine check enable
545 * bit 7: PGE Enable global pages
546 * bit 8: PCE Enable performance counters at IPL3
547 */
548 ERR("mov cr4,eax at 0x%08lx\n",context->Eip);
549 context->Eax = 0;
550 context->Eip += prefixlen+3;
551 return ExceptionContinueExecution;
552 case 0xc0: /* mov cr0, eax */
553 ERR("mov cr0,eax at 0x%08lx\n",context->Eip);
554 context->Eax = 0x10; /* FIXME: set more bits ? */
555 context->Eip += prefixlen+3;
556 return ExceptionContinueExecution;
557 default: /* fallthrough to illegal instruction */
558 break;
559 }
560 /* fallthrough to illegal instruction */
561 break;
562 case 0xa1: /* pop fs */
563 {
564 WORD seg = *(WORD *)get_stack( context );
565 if (INSTR_ReplaceSelector( context, &seg ))
566 {
567 context->SegFs = seg;
568 add_stack(context, long_op ? 4 : 2);
569 context->Eip += prefixlen + 2;
570 return ExceptionContinueExecution;
571 }
572 }
573 break;
574 case 0xa9: /* pop gs */
575 {
576 WORD seg = *(WORD *)get_stack( context );
577 if (INSTR_ReplaceSelector( context, &seg ))
578 {
579 context->SegGs = seg;
580 add_stack(context, long_op ? 4 : 2);
581 context->Eip += prefixlen + 2;
582 return ExceptionContinueExecution;
583 }
584 }
585 break;
586 case 0xb2: /* lss addr,reg */
587 case 0xb4: /* lfs addr,reg */
588 case 0xb5: /* lgs addr,reg */
589 if (INSTR_EmulateLDS( context, instr, long_op,
590 long_addr, segprefix, &len ))
591 {
592 context->Eip += prefixlen + len;
593 return ExceptionContinueExecution;
594 }
595 break;
596 }
597 break; /* Unable to emulate it */
598
599 case 0x6c: /* insb */
600 case 0x6d: /* insw/d */
601 case 0x6e: /* outsb */
602 case 0x6f: /* outsw/d */
603 {
604 int typ = *instr; /* Just in case it's overwritten. */
605 int outp = (typ >= 0x6e);
606 unsigned long count = repX ?
607 (long_addr ? context->Ecx : LOWORD(context->Ecx)) : 1;
608 int opsize = (typ & 1) ? (long_op ? 4 : 2) : 1;
609 int step = (context->EFlags & 0x400) ? -opsize : +opsize;
610 int seg = outp ? context->SegDs : context->SegEs; /* FIXME: is this right? */
611
612 if (outp)
613 /* FIXME: Check segment readable. */
614 (void)0;
615 else
616 /* FIXME: Check segment writeable. */
617 (void)0;
618
619 if (repX)
620 {
621 if (long_addr) context->Ecx = 0;
622 else SET_LOWORD(context->Ecx,0);
623 }
624
625 while (count-- > 0)
626 {
627 void *data;
628 WORD dx = LOWORD(context->Edx);
629 if (outp)
630 {
631 data = make_ptr( context, seg, context->Esi, long_addr );
632 if (long_addr) context->Esi += step;
633 else ADD_LOWORD(context->Esi,step);
634 }
635 else
636 {
637 data = make_ptr( context, seg, context->Edi, long_addr );
638 if (long_addr) context->Edi += step;
639 else ADD_LOWORD(context->Edi,step);
640 }
641
642 switch (typ)
643 {
644 case 0x6c:
645 *(BYTE *)data = INSTR_inport( dx, 1, context );
646 break;
647 case 0x6d:
648 if (long_op)
649 *(DWORD *)data = INSTR_inport( dx, 4, context );
650 else
651 *(WORD *)data = INSTR_inport( dx, 2, context );
652 break;
653 case 0x6e:
654 INSTR_outport( dx, 1, *(BYTE *)data, context );
655 break;
656 case 0x6f:
657 if (long_op)
658 INSTR_outport( dx, 4, *(DWORD *)data, context );
659 else
660 INSTR_outport( dx, 2, *(WORD *)data, context );
661 break;
662 }
663 }
664 context->Eip += prefixlen + 1;
665 }
666 return ExceptionContinueExecution;
667
668 case 0x8e: /* mov XX,segment_reg */
669 {
670 WORD seg;
671 BYTE *addr = INSTR_GetOperandAddr(context, instr + 1,
672 long_addr, segprefix, &len );
673 if (!addr)
674 break; /* Unable to emulate it */
675 seg = *(WORD *)addr;
676 if (!INSTR_ReplaceSelector( context, &seg ))
677 break; /* Unable to emulate it */
678
679 switch((instr[1] >> 3) & 7)
680 {
681 case 0:
682 context->SegEs = seg;
683 context->Eip += prefixlen + len + 1;
684 return ExceptionContinueExecution;
685 case 1: /* cs */
686 break;
687 case 2:
688 context->SegSs = seg;
689 context->Eip += prefixlen + len + 1;
690 return ExceptionContinueExecution;
691 case 3:
692 context->SegDs = seg;
693 context->Eip += prefixlen + len + 1;
694 return ExceptionContinueExecution;
695 case 4:
696 context->SegFs = seg;
697 context->Eip += prefixlen + len + 1;
698 return ExceptionContinueExecution;
699 case 5:
700 context->SegGs = seg;
701 context->Eip += prefixlen + len + 1;
702 return ExceptionContinueExecution;
703 case 6: /* unused */
704 case 7: /* unused */
705 break;
706 }
707 }
708 break; /* Unable to emulate it */
709
710 case 0xc4: /* les addr,reg */
711 case 0xc5: /* lds addr,reg */
712 if (INSTR_EmulateLDS( context, instr, long_op,
713 long_addr, segprefix, &len ))
714 {
715 context->Eip += prefixlen + len;
716 return ExceptionContinueExecution;
717 }
718 break; /* Unable to emulate it */
719
720 case 0xcd: /* int <XX> */
721 if (wine_ldt_is_system(context->SegCs)) break; /* don't emulate it in 32-bit code */
722 if (!DOS_EmulateInterruptPM) init_winedos();
723 if (DOS_EmulateInterruptPM)
724 {
725 context->Eip += prefixlen + 2;
726 DOS_EmulateInterruptPM( context, instr[1] );
727 return ExceptionContinueExecution;
728 }
729 break; /* Unable to emulate it */
730
731 case 0xcf: /* iret */
732 if (wine_ldt_is_system(context->SegCs)) break; /* don't emulate it in 32-bit code */
733 if (long_op)
734 {
735 DWORD *stack = get_stack( context );
736 context->Eip = *stack++;
737 context->SegCs = *stack++;
738 context->EFlags = *stack;
739 add_stack(context, 3*sizeof(DWORD)); /* Pop the return address and flags */
740 }
741 else
742 {
743 WORD *stack = get_stack( context );
744 context->Eip = *stack++;
745 context->SegCs = *stack++;
746 SET_LOWORD(context->EFlags,*stack);
747 add_stack(context, 3*sizeof(WORD)); /* Pop the return address and flags */
748 }
749 return ExceptionContinueExecution;
750
751 case 0xe4: /* inb al,XX */
752 SET_LOBYTE(context->Eax,INSTR_inport( instr[1], 1, context ));
753 context->Eip += prefixlen + 2;
754 return ExceptionContinueExecution;
755
756 case 0xe5: /* in (e)ax,XX */
757 if (long_op)
758 context->Eax = INSTR_inport( instr[1], 4, context );
759 else
760 SET_LOWORD(context->Eax, INSTR_inport( instr[1], 2, context ));
761 context->Eip += prefixlen + 2;
762 return ExceptionContinueExecution;
763
764 case 0xe6: /* outb XX,al */
765 INSTR_outport( instr[1], 1, LOBYTE(context->Eax), context );
766 context->Eip += prefixlen + 2;
767 return ExceptionContinueExecution;
768
769 case 0xe7: /* out XX,(e)ax */
770 if (long_op)
771 INSTR_outport( instr[1], 4, context->Eax, context );
772 else
773 INSTR_outport( instr[1], 2, LOWORD(context->Eax), context );
774 context->Eip += prefixlen + 2;
775 return ExceptionContinueExecution;
776
777 case 0xec: /* inb al,dx */
778 SET_LOBYTE(context->Eax, INSTR_inport( LOWORD(context->Edx), 1, context ) );
779 context->Eip += prefixlen + 1;
780 return ExceptionContinueExecution;
781
782 case 0xed: /* in (e)ax,dx */
783 if (long_op)
784 context->Eax = INSTR_inport( LOWORD(context->Edx), 4, context );
785 else
786 SET_LOWORD(context->Eax, INSTR_inport( LOWORD(context->Edx), 2, context ));
787 context->Eip += prefixlen + 1;
788 return ExceptionContinueExecution;
789
790 case 0xee: /* outb dx,al */
791 INSTR_outport( LOWORD(context->Edx), 1, LOBYTE(context->Eax), context );
792 context->Eip += prefixlen + 1;
793 return ExceptionContinueExecution;
794
795 case 0xef: /* out dx,(e)ax */
796 if (long_op)
797 INSTR_outport( LOWORD(context->Edx), 4, context->Eax, context );
798 else
799 INSTR_outport( LOWORD(context->Edx), 2, LOWORD(context->Eax), context );
800 context->Eip += prefixlen + 1;
801 return ExceptionContinueExecution;
802
803 case 0xfa: /* cli */
804 NtCurrentTeb()->dpmi_vif = 0;
805 context->Eip += prefixlen + 1;
806 return ExceptionContinueExecution;
807
808 case 0xfb: /* sti */
809 NtCurrentTeb()->dpmi_vif = 1;
810 context->Eip += prefixlen + 1;
811 return ExceptionContinueExecution;
812 }
813 return ExceptionContinueSearch; /* Unable to emulate it */
814 }
815
816
817 /***********************************************************************
818 * INSTR_CallBuiltinHandler
819 */
820 void INSTR_CallBuiltinHandler( CONTEXT86 *context, BYTE intnum )
821 {
822 if (!DOS_CallBuiltinHandler) init_winedos();
823 if (DOS_CallBuiltinHandler) DOS_CallBuiltinHandler( context, intnum );
824 }
825
826
827 /***********************************************************************
828 * DOS3Call (KERNEL.102)
829 */
830 void WINAPI DOS3Call( CONTEXT86 *context )
831 {
832 INSTR_CallBuiltinHandler( context, 0x21 );
833 }
834
835
836 /***********************************************************************
837 * NetBIOSCall (KERNEL.103)
838 */
839 void WINAPI NetBIOSCall16( CONTEXT86 *context )
840 {
841 INSTR_CallBuiltinHandler( context, 0x5c );
842 }
843
844
845 /***********************************************************************
846 * GetSetKernelDOSProc (KERNEL.311)
847 */
848 FARPROC16 WINAPI GetSetKernelDOSProc16( FARPROC16 DosProc )
849 {
850 FIXME("(DosProc=0x%08x): stub\n", (UINT)DosProc);
851 return NULL;
852 }