Includes/instr_set/opcodes_Grp3.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/>. */

/* ====================================================================
 *      0f6h
 * ==================================================================== */
void __bea_callspec__ G3_Eb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
        #endif
        EbIb(pMyDisasm);
        (*pMyDisasm).Argument1.AccessMode = READ;
        FillFlags(pMyDisasm, 104);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
        #endif
        EbIb(pMyDisasm);
        (*pMyDisasm).Argument1.AccessMode = READ;
        FillFlags(pMyDisasm, 104);
    }
    else if (GV.REGOPCODE == 2) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "not ");
        #endif
        Eb(pMyDisasm);
        FillFlags(pMyDisasm, 73);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "neg ");
        #endif
        Eb(pMyDisasm);
        FillFlags(pMyDisasm, 71);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mul ");
        #endif
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Argument1.ArgSize = 8;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0;
        FillFlags(pMyDisasm, 70);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
        #endif
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Argument1.ArgSize = 8;
        FillFlags(pMyDisasm, 38);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "div ");
        #endif
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Argument1.ArgSize = 8;
        FillFlags(pMyDisasm, 31);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "idiv ");
        #endif
        GV.MemDecoration = Arg2byte;
        GV.OperandSize = 8;
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.OperandSize = 32;
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Argument1.ArgSize = 8;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0;
        FillFlags(pMyDisasm, 37);
    }
}

/* ====================================================================
 *      0f7h
 * ==================================================================== */
void __bea_callspec__ G3_Ev(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    if (GV.REGOPCODE == 0) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
        #endif
        EvIv(pMyDisasm);
        (*pMyDisasm).Argument1.AccessMode = READ;
        FillFlags(pMyDisasm, 104);
    }
    else if (GV.REGOPCODE == 1) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
        #endif
        EvIv(pMyDisasm);
        (*pMyDisasm).Argument1.AccessMode = READ;
        FillFlags(pMyDisasm, 104);
    }
    else if (GV.REGOPCODE == 2) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "not ");
        #endif
        Ev(pMyDisasm);
        FillFlags(pMyDisasm, 73);
    }
    else if (GV.REGOPCODE == 3) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "neg ");
        #endif
        Ev(pMyDisasm);
        FillFlags(pMyDisasm, 71);
    }
    else if (GV.REGOPCODE == 4) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mul ");
        #endif
        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
                        (*pMyDisasm).Argument1.ArgSize = 64;                    
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2dword;
                        (*pMyDisasm).Argument1.ArgSize = 32;                            
        }
        else {
            GV.MemDecoration = Arg2word;
                        (*pMyDisasm).Argument1.ArgSize = 16;                            
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        FillFlags(pMyDisasm, 70);
    }
    else if (GV.REGOPCODE == 5) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
        #endif
        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
                        (*pMyDisasm).Argument1.ArgSize = 64;                    
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2dword;
                        (*pMyDisasm).Argument1.ArgSize = 32;                            
        }
        else {
            GV.MemDecoration = Arg2word;
                        (*pMyDisasm).Argument1.ArgSize = 16;                            
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        FillFlags(pMyDisasm, 38);
    }
    else if (GV.REGOPCODE == 6) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "div ");
        #endif
        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
                        (*pMyDisasm).Argument1.ArgSize = 64;                    
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2dword;
                        (*pMyDisasm).Argument1.ArgSize = 32;                            
        }
        else {
            GV.MemDecoration = Arg2word;
                        (*pMyDisasm).Argument1.ArgSize = 16;                            
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;            
        FillFlags(pMyDisasm, 31);
    }
    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "idiv ");
        #endif
        if (GV.OperandSize == 64) {
            GV.MemDecoration = Arg2qword;
                        (*pMyDisasm).Argument1.ArgSize = 64;                    
        }
        else if (GV.OperandSize == 32) {
            GV.MemDecoration = Arg2dword;
                        (*pMyDisasm).Argument1.ArgSize = 32;                            
        }
        else {
            GV.MemDecoration = Arg2word;
                        (*pMyDisasm).Argument1.ArgSize = 16;                            
        }
        MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
        GV.EIP_ += GV.DECALAGE_EIP+2;
        (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
        (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;            
        FillFlags(pMyDisasm, 37);
    }
}
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:	10842 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	* 0f6h
21	* ==================================================================== */
22	void __bea_callspec__ G3_Eb(PDISASM pMyDisasm)
23	{
24	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
25	if (GV.REGOPCODE == 0) {
26	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
27	#ifndef BEA_LIGHT_DISASSEMBLY
28	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
29	#endif
30	EbIb(pMyDisasm);
31	(*pMyDisasm).Argument1.AccessMode = READ;
32	FillFlags(pMyDisasm, 104);
33	}
34	else if (GV.REGOPCODE == 1) {
35	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
36	#ifndef BEA_LIGHT_DISASSEMBLY
37	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
38	#endif
39	EbIb(pMyDisasm);
40	(*pMyDisasm).Argument1.AccessMode = READ;
41	FillFlags(pMyDisasm, 104);
42	}
43	else if (GV.REGOPCODE == 2) {
44	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
45	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
46	}
47	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
48	#ifndef BEA_LIGHT_DISASSEMBLY
49	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "not ");
50	#endif
51	Eb(pMyDisasm);
52	FillFlags(pMyDisasm, 73);
53	}
54	else if (GV.REGOPCODE == 3) {
55	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
56	#ifndef BEA_LIGHT_DISASSEMBLY
57	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "neg ");
58	#endif
59	Eb(pMyDisasm);
60	FillFlags(pMyDisasm, 71);
61	}
62	else if (GV.REGOPCODE == 4) {
63	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
64	#ifndef BEA_LIGHT_DISASSEMBLY
65	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mul ");
66	#endif
67	GV.MemDecoration = Arg2byte;
68	GV.OperandSize = 8;
69	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
70	GV.OperandSize = 32;
71	GV.EIP_ += GV.DECALAGE_EIP+2;
72	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
73	(*pMyDisasm).Argument1.ArgSize = 8;
74	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0;
75	FillFlags(pMyDisasm, 70);
76	}
77	else if (GV.REGOPCODE == 5) {
78	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
79	#ifndef BEA_LIGHT_DISASSEMBLY
80	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
81	#endif
82	GV.MemDecoration = Arg2byte;
83	GV.OperandSize = 8;
84	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
85	GV.OperandSize = 32;
86	GV.EIP_ += GV.DECALAGE_EIP+2;
87	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
88	(*pMyDisasm).Argument1.ArgSize = 8;
89	FillFlags(pMyDisasm, 38);
90	}
91	else if (GV.REGOPCODE == 6) {
92	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
93	#ifndef BEA_LIGHT_DISASSEMBLY
94	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "div ");
95	#endif
96	GV.MemDecoration = Arg2byte;
97	GV.OperandSize = 8;
98	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
99	GV.OperandSize = 32;
100	GV.EIP_ += GV.DECALAGE_EIP+2;
101	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
102	(*pMyDisasm).Argument1.ArgSize = 8;
103	FillFlags(pMyDisasm, 31);
104	}
105	else if (GV.REGOPCODE == 7) {
106	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
107	#ifndef BEA_LIGHT_DISASSEMBLY
108	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "idiv ");
109	#endif
110	GV.MemDecoration = Arg2byte;
111	GV.OperandSize = 8;
112	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
113	GV.OperandSize = 32;
114	GV.EIP_ += GV.DECALAGE_EIP+2;
115	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
116	(*pMyDisasm).Argument1.ArgSize = 8;
117	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0;
118	FillFlags(pMyDisasm, 37);
119	}
120	}
121
122	/* ====================================================================
123	* 0f7h
124	* ==================================================================== */
125	void __bea_callspec__ G3_Ev(PDISASM pMyDisasm)
126	{
127	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
128	if (GV.REGOPCODE == 0) {
129	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
130	#ifndef BEA_LIGHT_DISASSEMBLY
131	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
132	#endif
133	EvIv(pMyDisasm);
134	(*pMyDisasm).Argument1.AccessMode = READ;
135	FillFlags(pMyDisasm, 104);
136	}
137	else if (GV.REGOPCODE == 1) {
138	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
139	#ifndef BEA_LIGHT_DISASSEMBLY
140	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
141	#endif
142	EvIv(pMyDisasm);
143	(*pMyDisasm).Argument1.AccessMode = READ;
144	FillFlags(pMyDisasm, 104);
145	}
146	else if (GV.REGOPCODE == 2) {
147	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
148	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
149	}
150	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
151	#ifndef BEA_LIGHT_DISASSEMBLY
152	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "not ");
153	#endif
154	Ev(pMyDisasm);
155	FillFlags(pMyDisasm, 73);
156	}
157	else if (GV.REGOPCODE == 3) {
158	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
159	#ifndef BEA_LIGHT_DISASSEMBLY
160	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "neg ");
161	#endif
162	Ev(pMyDisasm);
163	FillFlags(pMyDisasm, 71);
164	}
165	else if (GV.REGOPCODE == 4) {
166	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
167	#ifndef BEA_LIGHT_DISASSEMBLY
168	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mul ");
169	#endif
170	if (GV.OperandSize == 64) {
171	GV.MemDecoration = Arg2qword;
172	(*pMyDisasm).Argument1.ArgSize = 64;
173	}
174	else if (GV.OperandSize == 32) {
175	GV.MemDecoration = Arg2dword;
176	(*pMyDisasm).Argument1.ArgSize = 32;
177	}
178	else {
179	GV.MemDecoration = Arg2word;
180	(*pMyDisasm).Argument1.ArgSize = 16;
181	}
182	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
183	GV.EIP_ += GV.DECALAGE_EIP+2;
184	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
185	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
186	FillFlags(pMyDisasm, 70);
187	}
188	else if (GV.REGOPCODE == 5) {
189	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
190	#ifndef BEA_LIGHT_DISASSEMBLY
191	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
192	#endif
193	if (GV.OperandSize == 64) {
194	GV.MemDecoration = Arg2qword;
195	(*pMyDisasm).Argument1.ArgSize = 64;
196	}
197	else if (GV.OperandSize == 32) {
198	GV.MemDecoration = Arg2dword;
199	(*pMyDisasm).Argument1.ArgSize = 32;
200	}
201	else {
202	GV.MemDecoration = Arg2word;
203	(*pMyDisasm).Argument1.ArgSize = 16;
204	}
205	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
206	GV.EIP_ += GV.DECALAGE_EIP+2;
207	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
208	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
209	FillFlags(pMyDisasm, 38);
210	}
211	else if (GV.REGOPCODE == 6) {
212	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
213	#ifndef BEA_LIGHT_DISASSEMBLY
214	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "div ");
215	#endif
216	if (GV.OperandSize == 64) {
217	GV.MemDecoration = Arg2qword;
218	(*pMyDisasm).Argument1.ArgSize = 64;
219	}
220	else if (GV.OperandSize == 32) {
221	GV.MemDecoration = Arg2dword;
222	(*pMyDisasm).Argument1.ArgSize = 32;
223	}
224	else {
225	GV.MemDecoration = Arg2word;
226	(*pMyDisasm).Argument1.ArgSize = 16;
227	}
228	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
229	GV.EIP_ += GV.DECALAGE_EIP+2;
230	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
231	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
232	FillFlags(pMyDisasm, 31);
233	}
234	else if (GV.REGOPCODE == 7) {
235	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
236	#ifndef BEA_LIGHT_DISASSEMBLY
237	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "idiv ");
238	#endif
239	if (GV.OperandSize == 64) {
240	GV.MemDecoration = Arg2qword;
241	(*pMyDisasm).Argument1.ArgSize = 64;
242	}
243	else if (GV.OperandSize == 32) {
244	GV.MemDecoration = Arg2dword;
245	(*pMyDisasm).Argument1.ArgSize = 32;
246	}
247	else {
248	GV.MemDecoration = Arg2word;
249	(*pMyDisasm).Argument1.ArgSize = 16;
250	}
251	MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
252	GV.EIP_ += GV.DECALAGE_EIP+2;
253	(*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
254	(*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
255	FillFlags(pMyDisasm, 37);
256	}
257	}