source: Daodan/src/beaengine/Includes/instr_set/opcodes_Grp2.c@ 1100

Last change on this file since 1100 was 984, checked in by alloc, 11 years ago

Daodan: TV code
File size: 18.0 KB
RevLine 
[984]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 * ==================================================================== */
22void __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 * ==================================================================== */
88void __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 * ==================================================================== */
153void __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 * ==================================================================== */
229void __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 * ==================================================================== */
311void __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 * ==================================================================== */
386void __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}
Note: See TracBrowser for help on using the repository browser.