2 * Emulation of priviledged instructions
4 * Copyright 1995 Alexandre Julliard
7 #include "wine/winuser16.h"
13 #include "sig_context.h"
14 #include "selectors.h"
17 DECLARE_DEBUG_CHANNEL(int)
18 DECLARE_DEBUG_CHANNEL(io
)
21 #define IS_V86(context) (EFL_sig(context)&V86_FLAG)
22 #define IS_SEL_32(context,seg) \
23 (IS_V86(context) ? FALSE : IS_SELECTOR_32BIT(seg))
25 #define STACK_sig(context) \
26 (IS_SEL_32(context,SS_sig(context)) ? ESP_sig(context) : SP_sig(context))
28 #define MAKE_PTR(seg,off) \
29 (IS_SELECTOR_SYSTEM(seg) ? (void *)(off) : PTR_SEG_OFF_TO_LIN(seg,off))
31 #define MK_PTR(context,seg,off) \
32 (IS_V86(context) ? DOSMEM_MapRealToLinear(MAKELONG(off,seg)) \
35 #define STACK_PTR(context) \
36 (IS_V86(context) ? DOSMEM_MapRealToLinear(MAKELONG(SP_sig(context),SS_sig(context))) : \
37 (IS_SELECTOR_SYSTEM(SS_sig(context)) ? (void *)ESP_sig(context) : \
38 (PTR_SEG_OFF_TO_LIN(SS_sig(context),STACK_sig(context)))))
40 /* For invalid registers fixup */
41 extern DWORD CallFrom16_Start
,CallFrom16_End
;
42 extern DWORD CALLTO16_Start
,CALLTO16_End
;
45 /***********************************************************************
46 * INSTR_ReplaceSelector
48 * Try to replace an invalid selector by a valid one.
49 * The only selector where it is allowed to do "mov ax,40;mov es,ax"
50 * is the so called 'bimodal' selector 0x40, which points to the BIOS
51 * data segment. Used by (at least) Borland products (and programs compiled
52 * using Borland products).
54 * See Undocumented Windows, Chapter 5, __0040.
56 static BOOL
INSTR_ReplaceSelector( SIGCONTEXT
*context
, WORD
*sel
)
58 if ( IS_SELECTOR_SYSTEM(CS_sig(context
)) )
59 if ( ( EIP_sig(context
) >= (DWORD
)&CallFrom16_Start
&&
60 EIP_sig(context
) < (DWORD
)&CallFrom16_End
)
61 || ( EIP_sig(context
) >= (DWORD
)&CALLTO16_Start
&&
62 EIP_sig(context
) < (DWORD
)&CALLTO16_End
) )
64 /* Saved selector may have become invalid when the relay code */
65 /* tries to restore it. We simply clear it. */
72 static WORD sys_timer
= 0;
74 sys_timer
= CreateSystemTimer( 55, DOSMEM_Tick
);
75 *sel
= DOSMEM_BiosDataSeg
;
78 return FALSE
; /* Can't replace selector, crashdump */
82 /***********************************************************************
83 * INSTR_GetOperandAddr
85 * Return the address of an instruction operand (from the mod/rm byte).
87 static BYTE
*INSTR_GetOperandAddr( SIGCONTEXT
*context
, BYTE
*instr
,
88 int long_addr
, int segprefix
, int *len
)
90 int mod
, rm
, base
, index
= 0, ss
= 0, seg
= 0, off
;
92 #define GET_VAL(val,type) \
93 { *val = *(type *)instr; instr += sizeof(type); *len += sizeof(type); }
96 GET_VAL( &mod
, BYTE
);
104 case 0: return (BYTE
*)&EAX_sig(context
);
105 case 1: return (BYTE
*)&ECX_sig(context
);
106 case 2: return (BYTE
*)&EDX_sig(context
);
107 case 3: return (BYTE
*)&EBX_sig(context
);
108 case 4: return (BYTE
*)&ESP_sig(context
);
109 case 5: return (BYTE
*)&EBP_sig(context
);
110 case 6: return (BYTE
*)&ESI_sig(context
);
111 case 7: return (BYTE
*)&EDI_sig(context
);
120 GET_VAL( &sib
, BYTE
);
125 case 0: index
= EAX_sig(context
); break;
126 case 1: index
= ECX_sig(context
); break;
127 case 2: index
= EDX_sig(context
); break;
128 case 3: index
= EBX_sig(context
); break;
129 case 4: index
= 0; break;
130 case 5: index
= EBP_sig(context
); break;
131 case 6: index
= ESI_sig(context
); break;
132 case 7: index
= EDI_sig(context
); break;
138 case 0: base
= EAX_sig(context
); seg
= DS_sig(context
); break;
139 case 1: base
= ECX_sig(context
); seg
= DS_sig(context
); break;
140 case 2: base
= EDX_sig(context
); seg
= DS_sig(context
); break;
141 case 3: base
= EBX_sig(context
); seg
= DS_sig(context
); break;
142 case 4: base
= ESP_sig(context
); seg
= SS_sig(context
); break;
143 case 5: base
= EBP_sig(context
); seg
= SS_sig(context
); break;
144 case 6: base
= ESI_sig(context
); seg
= DS_sig(context
); break;
145 case 7: base
= EDI_sig(context
); seg
= DS_sig(context
); break;
150 if (rm
== 5) /* special case: ds:(disp32) */
152 GET_VAL( &base
, DWORD
);
153 seg
= DS_sig(context
);
157 case 1: /* 8-bit disp */
158 GET_VAL( &off
, BYTE
);
159 base
+= (signed char)off
;
162 case 2: /* 32-bit disp */
163 GET_VAL( &off
, DWORD
);
164 base
+= (signed long)off
;
168 else /* short address */
172 case 0: /* ds:(bx,si) */
173 base
= BX_sig(context
) + SI_sig(context
);
174 seg
= DS_sig(context
);
176 case 1: /* ds:(bx,di) */
177 base
= BX_sig(context
) + DI_sig(context
);
178 seg
= DS_sig(context
);
180 case 2: /* ss:(bp,si) */
181 base
= BP_sig(context
) + SI_sig(context
);
182 seg
= SS_sig(context
);
184 case 3: /* ss:(bp,di) */
185 base
= BP_sig(context
) + DI_sig(context
);
186 seg
= SS_sig(context
);
188 case 4: /* ds:(si) */
189 base
= SI_sig(context
);
190 seg
= DS_sig(context
);
192 case 5: /* ds:(di) */
193 base
= DI_sig(context
);
194 seg
= DS_sig(context
);
196 case 6: /* ss:(bp) */
197 base
= BP_sig(context
);
198 seg
= SS_sig(context
);
200 case 7: /* ds:(bx) */
201 base
= BX_sig(context
);
202 seg
= DS_sig(context
);
209 if (rm
== 6) /* special case: ds:(disp16) */
211 GET_VAL( &base
, WORD
);
212 seg
= DS_sig(context
);
216 case 1: /* 8-bit disp */
217 GET_VAL( &off
, BYTE
);
218 base
+= (signed char)off
;
221 case 2: /* 16-bit disp */
222 GET_VAL( &off
, WORD
);
223 base
+= (signed short)off
;
228 if (segprefix
!= -1) seg
= segprefix
;
230 /* Make sure the segment and offset are valid */
231 if (IS_SELECTOR_SYSTEM(seg
)) return (BYTE
*)(base
+ (index
<< ss
));
232 if (((seg
& 7) != 7) || IS_SELECTOR_FREE(seg
)) return NULL
;
233 if (GET_SEL_LIMIT(seg
) < (base
+ (index
<< ss
))) return NULL
;
234 return (BYTE
*)PTR_SEG_OFF_TO_LIN( seg
, (base
+ (index
<< ss
)) );
239 /***********************************************************************
242 * Emulate the LDS (and LES,LFS,etc.) instruction.
244 static BOOL
INSTR_EmulateLDS( SIGCONTEXT
*context
, BYTE
*instr
, int long_op
,
245 int long_addr
, int segprefix
, int *len
)
248 BYTE
*regmodrm
= instr
+ 1 + (*instr
== 0x0f);
249 BYTE
*addr
= INSTR_GetOperandAddr( context
, regmodrm
,
250 long_addr
, segprefix
, len
);
252 return FALSE
; /* Unable to emulate it */
253 seg
= *(WORD
*)(addr
+ (long_op
? 4 : 2));
255 if (!INSTR_ReplaceSelector( context
, &seg
))
256 return FALSE
; /* Unable to emulate it */
258 /* Now store the offset in the correct register */
260 switch((*regmodrm
>> 3) & 7)
263 if (long_op
) EAX_sig(context
) = *(DWORD
*)addr
;
264 else AX_sig(context
) = *(WORD
*)addr
;
267 if (long_op
) ECX_sig(context
) = *(DWORD
*)addr
;
268 else CX_sig(context
) = *(WORD
*)addr
;
271 if (long_op
) EDX_sig(context
) = *(DWORD
*)addr
;
272 else DX_sig(context
) = *(WORD
*)addr
;
275 if (long_op
) EBX_sig(context
) = *(DWORD
*)addr
;
276 else BX_sig(context
) = *(WORD
*)addr
;
279 if (long_op
) ESP_sig(context
) = *(DWORD
*)addr
;
280 else SP_sig(context
) = *(WORD
*)addr
;
283 if (long_op
) EBP_sig(context
) = *(DWORD
*)addr
;
284 else BP_sig(context
) = *(WORD
*)addr
;
287 if (long_op
) ESI_sig(context
) = *(DWORD
*)addr
;
288 else SI_sig(context
) = *(WORD
*)addr
;
291 if (long_op
) EDI_sig(context
) = *(DWORD
*)addr
;
292 else DI_sig(context
) = *(WORD
*)addr
;
296 /* Store the correct segment in the segment register */
300 case 0xc4: ES_sig(context
) = seg
; break; /* les */
301 case 0xc5: DS_sig(context
) = seg
; break; /* lds */
302 case 0x0f: switch(instr
[1])
304 case 0xb2: SS_sig(context
) = seg
; break; /* lss */
306 case 0xb4: FS_sig(context
) = seg
; break; /* lfs */
309 case 0xb5: GS_sig(context
) = seg
; break; /* lgs */
315 /* Add the opcode size to the total length */
317 *len
+= 1 + (*instr
== 0x0f);
322 /***********************************************************************
323 * INSTR_EmulateInstruction
325 * Emulate a priviledged instruction. Returns TRUE if emulation successful.
327 BOOL
INSTR_EmulateInstruction( SIGCONTEXT
*context
)
329 int prefix
, segprefix
, prefixlen
, len
, repX
, long_op
, long_addr
;
333 long_op
= long_addr
= IS_SEL_32(context
,CS_sig(context
));
334 instr
= (BYTE
*)MK_PTR(context
,CS_sig(context
),EIP_sig(context
));
335 if (!instr
) return FALSE
;
337 /* First handle any possible prefix */
339 segprefix
= -1; /* no prefix */
348 segprefix
= CS_sig(context
);
351 segprefix
= SS_sig(context
);
354 segprefix
= DS_sig(context
);
357 segprefix
= ES_sig(context
);
361 segprefix
= FS_sig(context
);
366 segprefix
= GS_sig(context
);
370 long_op
= !long_op
; /* opcode size prefix */
373 long_addr
= !long_addr
; /* addr size prefix */
375 case 0xf0: /* lock */
377 case 0xf2: /* repne */
380 case 0xf3: /* repe */
384 prefix
= 0; /* no more prefixes */
394 /* Now look at the actual instruction */
398 case 0x07: /* pop es */
399 case 0x17: /* pop ss */
400 case 0x1f: /* pop ds */
402 WORD seg
= *(WORD
*)STACK_PTR( context
);
403 if (INSTR_ReplaceSelector( context
, &seg
))
407 case 0x07: ES_sig(context
) = seg
; break;
408 case 0x17: SS_sig(context
) = seg
; break;
409 case 0x1f: DS_sig(context
) = seg
; break;
411 STACK_sig(context
) += long_op
? 4 : 2;
412 EIP_sig(context
) += prefixlen
+ 1;
416 break; /* Unable to emulate it */
418 case 0x0f: /* extended instruction */
421 case 0x22: /* mov eax, crX */
424 fprintf(stderr
,"mov eax,cr0 at 0x%08lx, EAX=0x%08lx\n",
425 EIP_sig(context
),EAX_sig(context
)
427 EIP_sig(context
) += prefixlen
+3;
430 break; /*fallthrough to bad instruction handling */
432 break; /*fallthrough to bad instruction handling */
433 case 0x20: /* mov crX, eax */
435 case 0xe0: /* mov cr4, eax */
436 /* CR4 register . See linux/arch/i386/mm/init.c, X86_CR4_ defs
437 * bit 0: VME Virtual Mode Exception ?
438 * bit 1: PVI Protected mode Virtual Interrupt
439 * bit 2: TSD Timestamp disable
440 * bit 3: DE Debugging extensions
441 * bit 4: PSE Page size extensions
442 * bit 5: PAE Physical address extension
443 * bit 6: MCE Machine check enable
444 * bit 7: PGE Enable global pages
445 * bit 8: PCE Enable performance counters at IPL3
447 fprintf(stderr
,"mov cr4,eax at 0x%08lx\n",EIP_sig(context
));
448 EAX_sig(context
) = 0;
449 EIP_sig(context
) += prefixlen
+3;
451 case 0xc0: /* mov cr0, eax */
452 fprintf(stderr
,"mov cr0,eax at 0x%08lx\n",EIP_sig(context
));
453 EAX_sig(context
) = 0x10; /* FIXME: set more bits ? */
454 EIP_sig(context
) += prefixlen
+3;
456 default: /* fallthrough to illegal instruction */
459 /* fallthrough to illegal instruction */
462 case 0xa1: /* pop fs */
464 WORD seg
= *(WORD
*)STACK_PTR( context
);
465 if (INSTR_ReplaceSelector( context
, &seg
))
467 FS_sig(context
) = seg
;
468 STACK_sig(context
) += long_op
? 4 : 2;
469 EIP_sig(context
) += prefixlen
+ 2;
477 case 0xa9: /* pop gs */
479 WORD seg
= *(WORD
*)STACK_PTR( context
);
480 if (INSTR_ReplaceSelector( context
, &seg
))
482 GS_sig(context
) = seg
;
483 STACK_sig(context
) += long_op
? 4 : 2;
484 EIP_sig(context
) += prefixlen
+ 2;
491 case 0xb2: /* lss addr,reg */
493 case 0xb4: /* lfs addr,reg */
496 case 0xb5: /* lgs addr,reg */
498 if (INSTR_EmulateLDS( context
, instr
, long_op
,
499 long_addr
, segprefix
, &len
))
501 EIP_sig(context
) += prefixlen
+ len
;
506 break; /* Unable to emulate it */
508 case 0x6c: /* insb */
509 case 0x6d: /* insw/d */
510 case 0x6e: /* outsb */
511 case 0x6f: /* outsw/d */
513 int typ
= *instr
; /* Just in case it's overwritten. */
514 int outp
= (typ
>= 0x6e);
515 unsigned long count
= repX
?
516 (long_addr
? ECX_sig(context
) : CX_sig(context
)) : 1;
517 int opsize
= (typ
& 1) ? (long_op
? 4 : 2) : 1;
518 int step
= (EFL_sig(context
) & 0x400) ? -opsize
: +opsize
;
519 int seg
= outp
? DS_sig(context
) : ES_sig(context
); /* FIXME: is this right? */
522 /* FIXME: Check segment readable. */
525 /* FIXME: Check segment writeable. */
531 ECX_sig(context
) = 0;
541 data
= MK_PTR(context
, seg
,
542 long_addr
? ESI_sig(context
) : SI_sig(context
));
543 if (long_addr
) ESI_sig(context
) += step
;
544 else SI_sig(context
) += step
;
548 data
= MK_PTR(context
, seg
,
549 long_addr
? EDI_sig(context
) : DI_sig(context
));
550 if (long_addr
) EDI_sig(context
) += step
;
551 else DI_sig(context
) += step
;
557 *((BYTE
*)data
) = IO_inport( DX_sig(context
), 1);
558 TRACE(io
, "0x%x < %02x @ %04x:%04x\n", DX_sig(context
),
559 *((BYTE
*)data
), CS_sig(context
), IP_sig(context
));
564 *((DWORD
*)data
) = IO_inport( DX_sig(context
), 4);
565 TRACE(io
, "0x%x < %08lx @ %04x:%04x\n", DX_sig(context
),
566 *((DWORD
*)data
), CS_sig(context
), IP_sig(context
));
570 *((WORD
*)data
) = IO_inport( DX_sig(context
), 2);
571 TRACE(io
, "0x%x < %04x @ %04x:%04x\n", DX_sig(context
),
572 *((WORD
*)data
), CS_sig(context
), IP_sig(context
));
576 IO_outport( DX_sig(context
), 1, *((BYTE
*)data
));
577 TRACE(io
, "0x%x > %02x @ %04x:%04x\n", DX_sig(context
),
578 *((BYTE
*)data
), CS_sig(context
), IP_sig(context
));
583 IO_outport( DX_sig(context
), 4, *((DWORD
*)data
));
584 TRACE(io
, "0x%x > %08lx @ %04x:%04x\n", DX_sig(context
),
585 *((DWORD
*)data
), CS_sig(context
), IP_sig(context
));
589 IO_outport( DX_sig(context
), 2, *((WORD
*)data
));
590 TRACE(io
, "0x%x > %04x @ %04x:%04x\n", DX_sig(context
),
591 *((WORD
*)data
), CS_sig(context
), IP_sig(context
));
596 EIP_sig(context
) += prefixlen
+ 1;
600 case 0x8e: /* mov XX,segment_reg */
603 BYTE
*addr
= INSTR_GetOperandAddr(context
, instr
+ 1,
604 long_addr
, segprefix
, &len
);
606 break; /* Unable to emulate it */
608 if (!INSTR_ReplaceSelector( context
, &seg
))
609 break; /* Unable to emulate it */
611 switch((instr
[1] >> 3) & 7)
614 ES_sig(context
) = seg
;
615 EIP_sig(context
) += prefixlen
+ len
+ 1;
620 SS_sig(context
) = seg
;
621 EIP_sig(context
) += prefixlen
+ len
+ 1;
624 DS_sig(context
) = seg
;
625 EIP_sig(context
) += prefixlen
+ len
+ 1;
629 FS_sig(context
) = seg
;
630 EIP_sig(context
) += prefixlen
+ len
+ 1;
635 GS_sig(context
) = seg
;
636 EIP_sig(context
) += prefixlen
+ len
+ 1;
644 break; /* Unable to emulate it */
646 case 0xc4: /* les addr,reg */
647 case 0xc5: /* lds addr,reg */
648 if (INSTR_EmulateLDS( context
, instr
, long_op
,
649 long_addr
, segprefix
, &len
))
651 EIP_sig(context
) += prefixlen
+ len
;
654 break; /* Unable to emulate it */
656 case 0xcd: /* int <XX> */
659 ERR(int, "int xx from 32-bit code is not supported.\n");
660 break; /* Unable to emulate it */
664 FARPROC16 addr
= INT_GetPMHandler( instr
[1] );
665 WORD
*stack
= (WORD
*)STACK_PTR( context
);
666 /* Push the flags and return address on the stack */
667 *(--stack
) = FL_sig(context
);
668 *(--stack
) = CS_sig(context
);
669 *(--stack
) = IP_sig(context
) + prefixlen
+ 2;
670 STACK_sig(context
) -= 3 * sizeof(WORD
);
671 /* Jump to the interrupt handler */
672 CS_sig(context
) = HIWORD(addr
);
673 EIP_sig(context
) = LOWORD(addr
);
677 case 0xcf: /* iret */
680 DWORD
*stack
= (DWORD
*)STACK_PTR( context
);
681 EIP_sig(context
) = *stack
++;
682 CS_sig(context
) = *stack
++;
683 EFL_sig(context
) = *stack
;
684 STACK_sig(context
) += 3*sizeof(DWORD
); /* Pop the return address and flags */
688 WORD
*stack
= (WORD
*)STACK_PTR( context
);
689 EIP_sig(context
) = *stack
++;
690 CS_sig(context
) = *stack
++;
691 FL_sig(context
) = *stack
;
692 STACK_sig(context
) += 3*sizeof(WORD
); /* Pop the return address and flags */
696 case 0xe4: /* inb al,XX */
697 AL_sig(context
) = IO_inport( instr
[1], 1 );
698 TRACE(io
, "0x%x < %02x @ %04x:%04x\n", instr
[1],
699 AL_sig(context
), CS_sig(context
), IP_sig(context
));
700 EIP_sig(context
) += prefixlen
+ 2;
703 case 0xe5: /* in (e)ax,XX */
706 EAX_sig(context
) = IO_inport( instr
[1], 4 );
707 TRACE(io
, "0x%x < %08lx @ %04x:%04x\n", instr
[1],
708 EAX_sig(context
), CS_sig(context
), IP_sig(context
));
712 AX_sig(context
) = IO_inport( instr
[1], 2 );
713 TRACE(io
, "0x%x < %04x @ %04x:%04x\n", instr
[1],
714 AX_sig(context
), CS_sig(context
), IP_sig(context
));
716 EIP_sig(context
) += prefixlen
+ 2;
719 case 0xe6: /* outb XX,al */
720 IO_outport( instr
[1], 1, AL_sig(context
) );
721 TRACE(io
, "0x%x > %02x @ %04x:%04x\n", instr
[1],
722 AL_sig(context
), CS_sig(context
), IP_sig(context
));
723 EIP_sig(context
) += prefixlen
+ 2;
726 case 0xe7: /* out XX,(e)ax */
729 IO_outport( instr
[1], 4, EAX_sig(context
) );
730 TRACE(io
, "0x%x > %08lx @ %04x:%04x\n", instr
[1],
731 EAX_sig(context
), CS_sig(context
), IP_sig(context
));
735 IO_outport( instr
[1], 2, AX_sig(context
) );
736 TRACE(io
, "0x%x > %04x @ %04x:%04x\n", instr
[1],
737 AX_sig(context
), CS_sig(context
), IP_sig(context
));
739 EIP_sig(context
) += prefixlen
+ 2;
742 case 0xec: /* inb al,dx */
743 AL_sig(context
) = IO_inport( DX_sig(context
), 1 );
744 TRACE(io
, "0x%x < %02x @ %04x:%04x\n", DX_sig(context
),
745 AL_sig(context
), CS_sig(context
), IP_sig(context
));
746 EIP_sig(context
) += prefixlen
+ 1;
749 case 0xed: /* in (e)ax,dx */
752 EAX_sig(context
) = IO_inport( DX_sig(context
), 4 );
753 TRACE(io
, "0x%x < %08lx @ %04x:%04x\n", DX_sig(context
),
754 EAX_sig(context
), CS_sig(context
), IP_sig(context
));
758 AX_sig(context
) = IO_inport( DX_sig(context
), 2 );
759 TRACE(io
, "0x%x < %04x @ %04x:%04x\n", DX_sig(context
),
760 AX_sig(context
), CS_sig(context
), IP_sig(context
));
762 EIP_sig(context
) += prefixlen
+ 1;
765 case 0xee: /* outb dx,al */
766 IO_outport( DX_sig(context
), 1, AL_sig(context
) );
767 TRACE(io
, "0x%x > %02x @ %04x:%04x\n", DX_sig(context
),
768 AL_sig(context
), CS_sig(context
), IP_sig(context
));
769 EIP_sig(context
) += prefixlen
+ 1;
772 case 0xef: /* out dx,(e)ax */
775 IO_outport( DX_sig(context
), 4, EAX_sig(context
) );
776 TRACE(io
, "0x%x > %08lx @ %04x:%04x\n", DX_sig(context
),
777 EAX_sig(context
), CS_sig(context
), IP_sig(context
));
781 IO_outport( DX_sig(context
), 2, AX_sig(context
) );
782 TRACE(io
, "0x%x > %04x @ %04x:%04x\n", DX_sig(context
),
783 AX_sig(context
), CS_sig(context
), IP_sig(context
));
785 EIP_sig(context
) += prefixlen
+ 1;
788 case 0xfa: /* cli, ignored */
789 EIP_sig(context
) += prefixlen
+ 1;
792 case 0xfb: /* sti, ignored */
793 EIP_sig(context
) += prefixlen
+ 1;
798 /* Check for Win16 __GP handler */
799 gpHandler
= HasGPHandler16( PTR_SEG_OFF_TO_SEGPTR( CS_sig(context
),
800 EIP_sig(context
) ) );
803 WORD
*stack
= (WORD
*)STACK_PTR( context
);
804 *--stack
= CS_sig(context
);
805 *--stack
= EIP_sig(context
);
806 STACK_sig(context
) -= 2*sizeof(WORD
);
808 CS_sig(context
) = SELECTOROF( gpHandler
);
809 EIP_sig(context
) = OFFSETOF( gpHandler
);
813 MSG("Unexpected Windows program segfault"
814 " - opcode = %x\n", *instr
);
815 return FALSE
; /* Unable to emulate it */