Includes/instr_set/opcodes_Grp2.c

/* Copyright 2006-2009, BeatriX
 * File coded by BeatriX
 *
 * This file is part of BeaEngine.
 *
 *    BeaEngine is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU Lesser General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    BeaEngine is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public License
 *    along with BeaEngine.  If not, see <http://www.gnu.org/licenses/>. */

/* ====================================================================
 *      0c0h
 * ==================================================================== */
void __bea_callspec__ G2_EbIb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    EbIb(pMyDisasm);
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
}


/* ====================================================================
 *      0c1h
 * ==================================================================== */
void __bea_callspec__ G2_EvIb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    EvIb(pMyDisasm);
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
}

/* ====================================================================
 *      0d0h
 * ==================================================================== */
void __bea_callspec__ G2_Eb1(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, "1 ");
    #endif
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.Immediat = 1;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 87);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 87);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 80);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 80);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    GV.EIP_ += GV.DECALAGE_EIP+2;
}


/* ====================================================================
 *      0d1h
 * ==================================================================== */
void __bea_callspec__ G2_Ev1(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg1qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg1dword;
    }
    else {
        GV.MemDecoration = Arg1word;
    }
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, "1 ");
    #endif
    (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
    (*pMyDisasm).Argument2.ArgSize = 8;
    (*pMyDisasm).Instruction.Immediat = 1;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 87);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 87);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 80);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 80);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 91);
    }
    GV.EIP_ += GV.DECALAGE_EIP+2;
}


/* ====================================================================
 *      0d2h
 * ==================================================================== */
void __bea_callspec__ G2_EbCL(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    GV.MemDecoration = Arg1byte;
    GV.OperandSize = 8;
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    GV.OperandSize = 32;
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[1]);
    #endif
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument2.ArgSize = 8;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    GV.EIP_ += GV.DECALAGE_EIP+2;
}


/* ====================================================================
 *      0d3h
 * ==================================================================== */
void __bea_callspec__ G2_EvCL(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.OperandSize == 64) {
        GV.MemDecoration = Arg1qword;
    }
    else if (GV.OperandSize == 32) {
        GV.MemDecoration = Arg1dword;
    }
    else {
        GV.MemDecoration = Arg1word;
    }
    MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
    #ifndef BEA_LIGHT_DISASSEMBLY
       (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[1]);
    #endif
    (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
    (*pMyDisasm).Argument2.ArgSize = 8;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
        #endif
        FillFlags(pMyDisasm, 88);
    }
    else if (GV.REGOPCODE == 2) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
        #endif
        FillFlags(pMyDisasm, 81);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
        #endif
        FillFlags(pMyDisasm, 92);
    }
    GV.EIP_ += GV.DECALAGE_EIP+2;
}
Revision:	984
Committed:	Sun Mar 16 23:35:10 2014 UTC (11 years, 6 months ago) by alloc
Content type:	text/x-csrc
File size:	18428 byte(s)
Log Message:	Daodan: TV code
#	Content
1	/* Copyright 2006-2009, BeatriX
2	* File coded by BeatriX
3	*
4	* This file is part of BeaEngine.
5	*
6	* BeaEngine is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU Lesser General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* BeaEngine 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
14	* GNU Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General Public License
17	* along with BeaEngine. If not, see <http://www.gnu.org/licenses/>. */
18
19	/* ====================================================================
20	* 0c0h
21	* ==================================================================== */
22	void __bea_callspec__ G2_EbIb(PDISASM pMyDisasm)
23	{
24	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
25	EbIb(pMyDisasm);
26	if (GV.REGOPCODE == 0) {
27	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
28	#ifndef BEA_LIGHT_DISASSEMBLY
29	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
30	#endif
31	FillFlags(pMyDisasm, 88);
32	}
33	else if (GV.REGOPCODE == 1) {
34	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
35	#ifndef BEA_LIGHT_DISASSEMBLY
36	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
37	#endif
38	FillFlags(pMyDisasm, 88);
39	}
40	else if (GV.REGOPCODE == 2) {
41	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
42	#ifndef BEA_LIGHT_DISASSEMBLY
43	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
44	#endif
45	FillFlags(pMyDisasm, 81);
46	}
47	else if (GV.REGOPCODE == 3) {
48	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
49	#ifndef BEA_LIGHT_DISASSEMBLY
50	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
51	#endif
52	FillFlags(pMyDisasm, 81);
53	}
54	else if (GV.REGOPCODE == 4) {
55	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
56	#ifndef BEA_LIGHT_DISASSEMBLY
57	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
58	#endif
59	FillFlags(pMyDisasm, 92);
60	}
61	else if (GV.REGOPCODE == 5) {
62	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
63	#ifndef BEA_LIGHT_DISASSEMBLY
64	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
65	#endif
66	FillFlags(pMyDisasm, 92);
67	}
68	else if (GV.REGOPCODE == 6) {
69	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
70	#ifndef BEA_LIGHT_DISASSEMBLY
71	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
72	#endif
73	FillFlags(pMyDisasm, 92);
74	}
75	else if (GV.REGOPCODE == 7) {
76	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
77	#ifndef BEA_LIGHT_DISASSEMBLY
78	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
79	#endif
80	FillFlags(pMyDisasm, 92);
81	}
82	}
83
84
85	/* ====================================================================
86	* 0c1h
87	* ==================================================================== */
88	void __bea_callspec__ G2_EvIb(PDISASM pMyDisasm)
89	{
90	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
91	EvIb(pMyDisasm);
92	if (GV.REGOPCODE == 0) {
93	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
94	#ifndef BEA_LIGHT_DISASSEMBLY
95	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
96	#endif
97	FillFlags(pMyDisasm, 88);
98	}
99	else if (GV.REGOPCODE == 1) {
100	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
101	#ifndef BEA_LIGHT_DISASSEMBLY
102	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
103	#endif
104	FillFlags(pMyDisasm, 88);
105	}
106	else if (GV.REGOPCODE == 2) {
107	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
108	#ifndef BEA_LIGHT_DISASSEMBLY
109	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
110	#endif
111	FillFlags(pMyDisasm, 81);
112	}
113	else if (GV.REGOPCODE == 3) {
114	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
115	#ifndef BEA_LIGHT_DISASSEMBLY
116	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
117	#endif
118	FillFlags(pMyDisasm, 81);
119	}
120	else if (GV.REGOPCODE == 4) {
121	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
122	#ifndef BEA_LIGHT_DISASSEMBLY
123	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
124	#endif
125	FillFlags(pMyDisasm, 92);
126	}
127	else if (GV.REGOPCODE == 5) {
128	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
129	#ifndef BEA_LIGHT_DISASSEMBLY
130	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
131	#endif
132	FillFlags(pMyDisasm, 92);
133	}
134	else if (GV.REGOPCODE == 6) {
135	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
136	#ifndef BEA_LIGHT_DISASSEMBLY
137	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
138	#endif
139	FillFlags(pMyDisasm, 92);
140	}
141	else if (GV.REGOPCODE == 7) {
142	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
143	#ifndef BEA_LIGHT_DISASSEMBLY
144	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
145	#endif
146	FillFlags(pMyDisasm, 92);
147	}
148	}
149
150	/* ====================================================================
151	* 0d0h
152	* ==================================================================== */
153	void __bea_callspec__ G2_Eb1(PDISASM pMyDisasm)
154	{
155	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
156	GV.MemDecoration = Arg1byte;
157	GV.OperandSize = 8;
158	MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
159	GV.OperandSize = 32;
160	#ifndef BEA_LIGHT_DISASSEMBLY
161	(void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, "1 ");
162	#endif
163	(*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
164	(*pMyDisasm).Argument2.ArgSize = 8;
165	(*pMyDisasm).Instruction.Immediat = 1;
166	if (GV.REGOPCODE == 0) {
167	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
168	#ifndef BEA_LIGHT_DISASSEMBLY
169	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
170	#endif
171	FillFlags(pMyDisasm, 87);
172	}
173	else if (GV.REGOPCODE == 1) {
174	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
175	#ifndef BEA_LIGHT_DISASSEMBLY
176	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
177	#endif
178	FillFlags(pMyDisasm, 87);
179	}
180	else if (GV.REGOPCODE == 2) {
181	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
182	#ifndef BEA_LIGHT_DISASSEMBLY
183	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
184	#endif
185	FillFlags(pMyDisasm, 80);
186	}
187	else if (GV.REGOPCODE == 3) {
188	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
189	#ifndef BEA_LIGHT_DISASSEMBLY
190	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
191	#endif
192	FillFlags(pMyDisasm, 80);
193	}
194	else if (GV.REGOPCODE == 4) {
195	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
196	#ifndef BEA_LIGHT_DISASSEMBLY
197	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
198	#endif
199	FillFlags(pMyDisasm, 91);
200	}
201	else if (GV.REGOPCODE == 5) {
202	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
203	#ifndef BEA_LIGHT_DISASSEMBLY
204	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
205	#endif
206	FillFlags(pMyDisasm, 91);
207	}
208	else if (GV.REGOPCODE == 6) {
209	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
210	#ifndef BEA_LIGHT_DISASSEMBLY
211	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
212	#endif
213	FillFlags(pMyDisasm, 91);
214	}
215	else if (GV.REGOPCODE == 7) {
216	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
217	#ifndef BEA_LIGHT_DISASSEMBLY
218	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
219	#endif
220	FillFlags(pMyDisasm, 91);
221	}
222	GV.EIP_ += GV.DECALAGE_EIP+2;
223	}
224
225
226	/* ====================================================================
227	* 0d1h
228	* ==================================================================== */
229	void __bea_callspec__ G2_Ev1(PDISASM pMyDisasm)
230	{
231	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
232	if (GV.OperandSize == 64) {
233	GV.MemDecoration = Arg1qword;
234	}
235	else if (GV.OperandSize == 32) {
236	GV.MemDecoration = Arg1dword;
237	}
238	else {
239	GV.MemDecoration = Arg1word;
240	}
241	MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
242	#ifndef BEA_LIGHT_DISASSEMBLY
243	(void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, "1 ");
244	#endif
245	(*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
246	(*pMyDisasm).Argument2.ArgSize = 8;
247	(*pMyDisasm).Instruction.Immediat = 1;
248	if (GV.REGOPCODE == 0) {
249	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
250	#ifndef BEA_LIGHT_DISASSEMBLY
251	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
252	#endif
253	FillFlags(pMyDisasm, 87);
254	}
255	else if (GV.REGOPCODE == 1) {
256	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
257	#ifndef BEA_LIGHT_DISASSEMBLY
258	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
259	#endif
260	FillFlags(pMyDisasm, 87);
261	}
262	else if (GV.REGOPCODE == 2) {
263	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
264	#ifndef BEA_LIGHT_DISASSEMBLY
265	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
266	#endif
267	FillFlags(pMyDisasm, 80);
268	}
269	else if (GV.REGOPCODE == 3) {
270	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
271	#ifndef BEA_LIGHT_DISASSEMBLY
272	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
273	#endif
274	FillFlags(pMyDisasm, 80);
275	}
276	else if (GV.REGOPCODE == 4) {
277	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
278	#ifndef BEA_LIGHT_DISASSEMBLY
279	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
280	#endif
281	FillFlags(pMyDisasm, 91);
282	}
283	else if (GV.REGOPCODE == 5) {
284	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
285	#ifndef BEA_LIGHT_DISASSEMBLY
286	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
287	#endif
288	FillFlags(pMyDisasm, 91);
289	}
290	else if (GV.REGOPCODE == 6) {
291	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
292	#ifndef BEA_LIGHT_DISASSEMBLY
293	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
294	#endif
295	FillFlags(pMyDisasm, 91);
296	}
297	else if (GV.REGOPCODE == 7) {
298	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
299	#ifndef BEA_LIGHT_DISASSEMBLY
300	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
301	#endif
302	FillFlags(pMyDisasm, 91);
303	}
304	GV.EIP_ += GV.DECALAGE_EIP+2;
305	}
306
307
308	/* ====================================================================
309	* 0d2h
310	* ==================================================================== */
311	void __bea_callspec__ G2_EbCL(PDISASM pMyDisasm)
312	{
313	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
314	GV.MemDecoration = Arg1byte;
315	GV.OperandSize = 8;
316	MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
317	GV.OperandSize = 32;
318	#ifndef BEA_LIGHT_DISASSEMBLY
319	(void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[1]);
320	#endif
321	(*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
322	(*pMyDisasm).Argument2.ArgSize = 8;
323	if (GV.REGOPCODE == 0) {
324	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
325	#ifndef BEA_LIGHT_DISASSEMBLY
326	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
327	#endif
328	FillFlags(pMyDisasm, 88);
329	}
330	else if (GV.REGOPCODE == 1) {
331	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
332	#ifndef BEA_LIGHT_DISASSEMBLY
333	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
334	#endif
335	FillFlags(pMyDisasm, 88);
336	}
337	else if (GV.REGOPCODE == 2) {
338	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
339	#ifndef BEA_LIGHT_DISASSEMBLY
340	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
341	#endif
342	FillFlags(pMyDisasm, 81);
343	}
344	else if (GV.REGOPCODE == 3) {
345	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
346	#ifndef BEA_LIGHT_DISASSEMBLY
347	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
348	#endif
349	FillFlags(pMyDisasm, 81);
350	}
351	else if (GV.REGOPCODE == 4) {
352	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
353	#ifndef BEA_LIGHT_DISASSEMBLY
354	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
355	#endif
356	FillFlags(pMyDisasm, 92);
357	}
358	else if (GV.REGOPCODE == 5) {
359	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
360	#ifndef BEA_LIGHT_DISASSEMBLY
361	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
362	#endif
363	FillFlags(pMyDisasm, 92);
364	}
365	else if (GV.REGOPCODE == 6) {
366	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
367	#ifndef BEA_LIGHT_DISASSEMBLY
368	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
369	#endif
370	FillFlags(pMyDisasm, 92);
371	}
372	else if (GV.REGOPCODE == 7) {
373	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
374	#ifndef BEA_LIGHT_DISASSEMBLY
375	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
376	#endif
377	FillFlags(pMyDisasm, 92);
378	}
379	GV.EIP_ += GV.DECALAGE_EIP+2;
380	}
381
382
383	/* ====================================================================
384	* 0d3h
385	* ==================================================================== */
386	void __bea_callspec__ G2_EvCL(PDISASM pMyDisasm)
387	{
388	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
389	if (GV.OperandSize == 64) {
390	GV.MemDecoration = Arg1qword;
391	}
392	else if (GV.OperandSize == 32) {
393	GV.MemDecoration = Arg1dword;
394	}
395	else {
396	GV.MemDecoration = Arg1word;
397	}
398	MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
399	#ifndef BEA_LIGHT_DISASSEMBLY
400	(void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[1]);
401	#endif
402	(*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
403	(*pMyDisasm).Argument2.ArgSize = 8;
404	if (GV.REGOPCODE == 0) {
405	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
406	#ifndef BEA_LIGHT_DISASSEMBLY
407	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rol ");
408	#endif
409	FillFlags(pMyDisasm, 88);
410	}
411	else if (GV.REGOPCODE == 1) {
412	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
413	#ifndef BEA_LIGHT_DISASSEMBLY
414	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ror ");
415	#endif
416	FillFlags(pMyDisasm, 88);
417	}
418	else if (GV.REGOPCODE == 2) {
419	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
420	#ifndef BEA_LIGHT_DISASSEMBLY
421	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcl ");
422	#endif
423	FillFlags(pMyDisasm, 81);
424	}
425	else if (GV.REGOPCODE == 3) {
426	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
427	#ifndef BEA_LIGHT_DISASSEMBLY
428	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcr ");
429	#endif
430	FillFlags(pMyDisasm, 81);
431	}
432	else if (GV.REGOPCODE == 4) {
433	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
434	#ifndef BEA_LIGHT_DISASSEMBLY
435	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shl ");
436	#endif
437	FillFlags(pMyDisasm, 92);
438	}
439	else if (GV.REGOPCODE == 5) {
440	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
441	#ifndef BEA_LIGHT_DISASSEMBLY
442	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shr ");
443	#endif
444	FillFlags(pMyDisasm, 92);
445	}
446	else if (GV.REGOPCODE == 6) {
447	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
448	#ifndef BEA_LIGHT_DISASSEMBLY
449	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sal ");
450	#endif
451	FillFlags(pMyDisasm, 92);
452	}
453	else if (GV.REGOPCODE == 7) {
454	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
455	#ifndef BEA_LIGHT_DISASSEMBLY
456	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sar ");
457	#endif
458	FillFlags(pMyDisasm, 92);
459	}
460	GV.EIP_ += GV.DECALAGE_EIP+2;
461	}