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

/* ====================================================================
 *      80h
 * ==================================================================== */
void __bea_callspec__ G1_EbIb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    EbIb(pMyDisasm);
    if (GV.REGOPCODE == 0) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
        #endif
        FillFlags(pMyDisasm, 5);
    }
    else if (GV.REGOPCODE == 1) {
        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, "or ");
        #endif
        FillFlags(pMyDisasm, 74);
    }
    else if (GV.REGOPCODE == 2) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
        #endif
        FillFlags(pMyDisasm, 4);
    }
    else if (GV.REGOPCODE == 3) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
        #endif
        FillFlags(pMyDisasm, 93);
    }
    else if (GV.REGOPCODE == 4) {
        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, "and ");
        #endif
        FillFlags(pMyDisasm, 6);
    }
    else if (GV.REGOPCODE == 5) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
        #endif
        FillFlags(pMyDisasm, 103);
    }

    else if (GV.REGOPCODE == 6) {
        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, "xor ");
        #endif
        FillFlags(pMyDisasm, 113);
    }

    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
        #endif
        FillFlags(pMyDisasm, 20);
        (*pMyDisasm).Argument1.AccessMode = READ;
    }
}

/* ====================================================================
 *      82h
 * ==================================================================== */
void __bea_callspec__ G1_EbIb2(PDISASM pMyDisasm)
{
    if (GV.Architecture == 64) {
        FailDecode(pMyDisasm);
    }
    else {
        G1_EbIb(pMyDisasm);
    }
}

/* ====================================================================
 *      81h
 * ==================================================================== */
void __bea_callspec__ G1_EvIv(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    EvIv(pMyDisasm);
    if (GV.REGOPCODE == 0) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
        #endif
        FillFlags(pMyDisasm, 5);
    }
    else if (GV.REGOPCODE == 1) {
        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, "or ");
        #endif
        FillFlags(pMyDisasm, 74);
    }
    else if (GV.REGOPCODE == 2) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
        #endif
        FillFlags(pMyDisasm, 4);
    }
    else if (GV.REGOPCODE == 3) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
        #endif
        FillFlags(pMyDisasm, 93);
    }
    else if (GV.REGOPCODE == 4) {
        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, "and ");
        #endif
        FillFlags(pMyDisasm, 6);
    }
    else if (GV.REGOPCODE == 5) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
        #endif
        FillFlags(pMyDisasm, 103);
    }

    else if (GV.REGOPCODE == 6) {
        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, "xor ");
        #endif
        FillFlags(pMyDisasm, 113);
    }

    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
        #endif
        FillFlags(pMyDisasm, 20);
        (*pMyDisasm).Argument1.AccessMode = READ;
    }
}

/* ====================================================================
 *      83h
 * ==================================================================== */
void __bea_callspec__ G1_EvIb(PDISASM pMyDisasm)
{
    GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
    EvIb(pMyDisasm);
    if (GV.REGOPCODE == 0) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
        #endif
        FillFlags(pMyDisasm, 5);
    }
    else if (GV.REGOPCODE == 1) {
        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, "or ");
        #endif
        FillFlags(pMyDisasm, 74);
    }
    else if (GV.REGOPCODE == 2) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
        #endif
        FillFlags(pMyDisasm, 4);
    }
    else if (GV.REGOPCODE == 3) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
        #endif
        FillFlags(pMyDisasm, 93);
    }
    else if (GV.REGOPCODE == 4) {
        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, "and ");
        #endif
        FillFlags(pMyDisasm, 6);
    }
    else if (GV.REGOPCODE == 5) {
        if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
            (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
        }
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
        #endif
        FillFlags(pMyDisasm, 103);
    }

    else if (GV.REGOPCODE == 6) {
        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, "xor ");
        #endif
        FillFlags(pMyDisasm, 113);
    }

    else if (GV.REGOPCODE == 7) {
        (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
        #ifndef BEA_LIGHT_DISASSEMBLY
           (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
        #endif
        FillFlags(pMyDisasm, 20);
        (*pMyDisasm).Argument1.AccessMode = READ;
    }
}
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:	12212 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	* 80h
21	* ==================================================================== */
22	void __bea_callspec__ G1_EbIb(PDISASM pMyDisasm)
23	{
24	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
25	EbIb(pMyDisasm);
26	if (GV.REGOPCODE == 0) {
27	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
28	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
29	}
30	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
31	#ifndef BEA_LIGHT_DISASSEMBLY
32	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
33	#endif
34	FillFlags(pMyDisasm, 5);
35	}
36	else if (GV.REGOPCODE == 1) {
37	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
38	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
39	}
40	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
41	#ifndef BEA_LIGHT_DISASSEMBLY
42	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
43	#endif
44	FillFlags(pMyDisasm, 74);
45	}
46	else if (GV.REGOPCODE == 2) {
47	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
48	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
49	}
50	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
51	#ifndef BEA_LIGHT_DISASSEMBLY
52	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
53	#endif
54	FillFlags(pMyDisasm, 4);
55	}
56	else if (GV.REGOPCODE == 3) {
57	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
58	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
59	}
60	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
61	#ifndef BEA_LIGHT_DISASSEMBLY
62	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
63	#endif
64	FillFlags(pMyDisasm, 93);
65	}
66	else if (GV.REGOPCODE == 4) {
67	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
68	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
69	}
70	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
71	#ifndef BEA_LIGHT_DISASSEMBLY
72	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
73	#endif
74	FillFlags(pMyDisasm, 6);
75	}
76	else if (GV.REGOPCODE == 5) {
77	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
78	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
79	}
80	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
81	#ifndef BEA_LIGHT_DISASSEMBLY
82	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
83	#endif
84	FillFlags(pMyDisasm, 103);
85	}
86
87	else if (GV.REGOPCODE == 6) {
88	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
89	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
90	}
91	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
92	#ifndef BEA_LIGHT_DISASSEMBLY
93	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
94	#endif
95	FillFlags(pMyDisasm, 113);
96	}
97
98	else if (GV.REGOPCODE == 7) {
99	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
100	#ifndef BEA_LIGHT_DISASSEMBLY
101	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
102	#endif
103	FillFlags(pMyDisasm, 20);
104	(*pMyDisasm).Argument1.AccessMode = READ;
105	}
106	}
107
108	/* ====================================================================
109	* 82h
110	* ==================================================================== */
111	void __bea_callspec__ G1_EbIb2(PDISASM pMyDisasm)
112	{
113	if (GV.Architecture == 64) {
114	FailDecode(pMyDisasm);
115	}
116	else {
117	G1_EbIb(pMyDisasm);
118	}
119	}
120
121	/* ====================================================================
122	* 81h
123	* ==================================================================== */
124	void __bea_callspec__ G1_EvIv(PDISASM pMyDisasm)
125	{
126	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
127	EvIv(pMyDisasm);
128	if (GV.REGOPCODE == 0) {
129	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
130	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
131	}
132	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
133	#ifndef BEA_LIGHT_DISASSEMBLY
134	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
135	#endif
136	FillFlags(pMyDisasm, 5);
137	}
138	else if (GV.REGOPCODE == 1) {
139	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
140	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
141	}
142	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
143	#ifndef BEA_LIGHT_DISASSEMBLY
144	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
145	#endif
146	FillFlags(pMyDisasm, 74);
147	}
148	else if (GV.REGOPCODE == 2) {
149	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
150	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
151	}
152	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
153	#ifndef BEA_LIGHT_DISASSEMBLY
154	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
155	#endif
156	FillFlags(pMyDisasm, 4);
157	}
158	else if (GV.REGOPCODE == 3) {
159	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
160	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
161	}
162	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
163	#ifndef BEA_LIGHT_DISASSEMBLY
164	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
165	#endif
166	FillFlags(pMyDisasm, 93);
167	}
168	else if (GV.REGOPCODE == 4) {
169	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
170	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
171	}
172	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
173	#ifndef BEA_LIGHT_DISASSEMBLY
174	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
175	#endif
176	FillFlags(pMyDisasm, 6);
177	}
178	else if (GV.REGOPCODE == 5) {
179	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
180	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
181	}
182	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
183	#ifndef BEA_LIGHT_DISASSEMBLY
184	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
185	#endif
186	FillFlags(pMyDisasm, 103);
187	}
188
189	else if (GV.REGOPCODE == 6) {
190	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
191	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
192	}
193	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
194	#ifndef BEA_LIGHT_DISASSEMBLY
195	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
196	#endif
197	FillFlags(pMyDisasm, 113);
198	}
199
200	else if (GV.REGOPCODE == 7) {
201	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
202	#ifndef BEA_LIGHT_DISASSEMBLY
203	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
204	#endif
205	FillFlags(pMyDisasm, 20);
206	(*pMyDisasm).Argument1.AccessMode = READ;
207	}
208	}
209
210	/* ====================================================================
211	* 83h
212	* ==================================================================== */
213	void __bea_callspec__ G1_EvIb(PDISASM pMyDisasm)
214	{
215	GV.REGOPCODE = ((((UInt8)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
216	EvIb(pMyDisasm);
217	if (GV.REGOPCODE == 0) {
218	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
219	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
220	}
221	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
222	#ifndef BEA_LIGHT_DISASSEMBLY
223	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
224	#endif
225	FillFlags(pMyDisasm, 5);
226	}
227	else if (GV.REGOPCODE == 1) {
228	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
229	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
230	}
231	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
232	#ifndef BEA_LIGHT_DISASSEMBLY
233	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
234	#endif
235	FillFlags(pMyDisasm, 74);
236	}
237	else if (GV.REGOPCODE == 2) {
238	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
239	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
240	}
241	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
242	#ifndef BEA_LIGHT_DISASSEMBLY
243	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
244	#endif
245	FillFlags(pMyDisasm, 4);
246	}
247	else if (GV.REGOPCODE == 3) {
248	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
249	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
250	}
251	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
252	#ifndef BEA_LIGHT_DISASSEMBLY
253	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
254	#endif
255	FillFlags(pMyDisasm, 93);
256	}
257	else if (GV.REGOPCODE == 4) {
258	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
259	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
260	}
261	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
262	#ifndef BEA_LIGHT_DISASSEMBLY
263	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
264	#endif
265	FillFlags(pMyDisasm, 6);
266	}
267	else if (GV.REGOPCODE == 5) {
268	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
269	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
270	}
271	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
272	#ifndef BEA_LIGHT_DISASSEMBLY
273	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
274	#endif
275	FillFlags(pMyDisasm, 103);
276	}
277
278	else if (GV.REGOPCODE == 6) {
279	if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
280	(*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
281	}
282	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
283	#ifndef BEA_LIGHT_DISASSEMBLY
284	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
285	#endif
286	FillFlags(pMyDisasm, 113);
287	}
288
289	else if (GV.REGOPCODE == 7) {
290	(*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
291	#ifndef BEA_LIGHT_DISASSEMBLY
292	(void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
293	#endif
294	FillFlags(pMyDisasm, 20);
295	(*pMyDisasm).Argument1.AccessMode = READ;
296	}
297	}