source: Daodan/src/beaengine/Includes/instr_set/opcodes_N_Z.c@ 986

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

Daodan: TV code
File size: 135.0 KB
Line 
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 * 90h
21 * ==================================================================== */
22void __bea_callspec__ nop_(PDISASM pMyDisasm)
23{
24 if (GV.PrefRepe == 1) {
25 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
26 #ifndef BEA_LIGHT_DISASSEMBLY
27 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pause ");
28 #endif
29 GV.EIP_++;
30 }
31 else {
32 if (GV.REX.B_ == 1) {
33 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
34 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
35 }
36 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
37 #ifndef BEA_LIGHT_DISASSEMBLY
38 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
39 #endif
40
41 if (GV.OperandSize == 64) {
42 #ifndef BEA_LIGHT_DISASSEMBLY
43 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
44 #endif
45
46 #ifndef BEA_LIGHT_DISASSEMBLY
47 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[0+8]);
48 #endif
49 GV.EIP_++;
50 (*pMyDisasm).Argument2.AccessMode = WRITE;
51 (*pMyDisasm).Argument1.ArgSize = 64;
52 (*pMyDisasm).Argument2.ArgSize = 64;
53 }
54 else if (GV.OperandSize == 32) {
55 #ifndef BEA_LIGHT_DISASSEMBLY
56 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
57 #endif
58
59 #ifndef BEA_LIGHT_DISASSEMBLY
60 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0+8]);
61 #endif
62
63 GV.EIP_++;
64 (*pMyDisasm).Argument2.AccessMode = WRITE;
65 (*pMyDisasm).Argument1.ArgSize = 32;
66 (*pMyDisasm).Argument2.ArgSize = 32;
67 }
68 else {
69 #ifndef BEA_LIGHT_DISASSEMBLY
70 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
71 #endif
72
73 #ifndef BEA_LIGHT_DISASSEMBLY
74 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0+8]);
75 #endif
76
77 GV.EIP_++;
78 (*pMyDisasm).Argument2.AccessMode = WRITE;
79 (*pMyDisasm).Argument1.ArgSize = 16;
80 (*pMyDisasm).Argument2.ArgSize = 16;
81 }
82
83 }
84 else {
85 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
86 #ifndef BEA_LIGHT_DISASSEMBLY
87 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "nop ");
88 #endif
89 GV.EIP_++;
90 }
91 }
92}
93
94/* =======================================
95 *
96 * ======================================= */
97void __bea_callspec__ nop_Ev(PDISASM pMyDisasm)
98{
99 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
100 #ifndef BEA_LIGHT_DISASSEMBLY
101 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "nop ");
102 #endif
103 if (GV.OperandSize == 64) {
104 GV.MemDecoration = Arg2qword;
105 }
106 else if (GV.OperandSize == 32) {
107 GV.MemDecoration = Arg2dword;
108 }
109 else {
110 GV.MemDecoration = Arg2word;
111 }
112 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
113 GV.EIP_ += GV.DECALAGE_EIP+2;
114 (*pMyDisasm).Argument2.AccessMode = 0;
115}
116
117/* =======================================
118 *
119 * ======================================= */
120void __bea_callspec__ hint_nop(PDISASM pMyDisasm)
121{
122 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
123 #ifndef BEA_LIGHT_DISASSEMBLY
124 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hint_nop ");
125 #endif
126 if (GV.OperandSize == 64) {
127 GV.MemDecoration = Arg2qword;
128 }
129 else if (GV.OperandSize == 32) {
130 GV.MemDecoration = Arg2dword;
131 }
132 else {
133 GV.MemDecoration = Arg2word;
134 }
135 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
136 GV.EIP_ += GV.DECALAGE_EIP+2;
137}
138
139/* =======================================
140 * 08h
141 * ======================================= */
142void __bea_callspec__ or_EbGb(PDISASM pMyDisasm)
143{
144 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
145 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
146 }
147 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
148 #ifndef BEA_LIGHT_DISASSEMBLY
149 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
150 #endif
151 EbGb(pMyDisasm);
152 FillFlags(pMyDisasm,74);
153}
154
155/* =======================================
156 * 09h
157 * ======================================= */
158void __bea_callspec__ or_EvGv(PDISASM pMyDisasm)
159{
160 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
161 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
162 }
163 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
164 #ifndef BEA_LIGHT_DISASSEMBLY
165 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
166 #endif
167 EvGv(pMyDisasm);
168 FillFlags(pMyDisasm,74);
169}
170
171/* =======================================
172 * 0ah
173 * ======================================= */
174void __bea_callspec__ or_GbEb(PDISASM pMyDisasm)
175{
176 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
177 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
178 }
179 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
180 #ifndef BEA_LIGHT_DISASSEMBLY
181 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
182 #endif
183 GbEb(pMyDisasm);
184 FillFlags(pMyDisasm,74);
185}
186
187/* =======================================
188 * 0bh
189 * ======================================= */
190void __bea_callspec__ or_GvEv(PDISASM pMyDisasm)
191{
192 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
193 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
194 }
195 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
196 #ifndef BEA_LIGHT_DISASSEMBLY
197 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
198 #endif
199 GvEv(pMyDisasm);
200 FillFlags(pMyDisasm,74);
201}
202
203/* =======================================
204 * 0ch
205 * ======================================= */
206void __bea_callspec__ or_ALIb(PDISASM pMyDisasm)
207{
208 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
209 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
210 }
211 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
212 #ifndef BEA_LIGHT_DISASSEMBLY
213 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
214 #endif
215 ALIb(pMyDisasm);
216 FillFlags(pMyDisasm,74);
217}
218
219/* =======================================
220 * 0dh
221 * ======================================= */
222void __bea_callspec__ or_eAX_Iv(PDISASM pMyDisasm)
223{
224 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
225 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
226 }
227 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
228 #ifndef BEA_LIGHT_DISASSEMBLY
229 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "or ");
230 #endif
231 eAX_Iv(pMyDisasm);
232 FillFlags(pMyDisasm,74);
233}
234
235
236/* =======================================
237 * 06eh
238 * ======================================= */
239void __bea_callspec__ outsb_(PDISASM pMyDisasm)
240{
241 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
242 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
243 }
244 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
245 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
246 }
247 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
248 #ifndef BEA_LIGHT_DISASSEMBLY
249 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "outsb ");
250 #endif
251 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
252 (*pMyDisasm).Argument1.ArgSize = 16;
253 (*pMyDisasm).Argument1.AccessMode = READ;
254 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
255 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
256 (*pMyDisasm).Argument2.ArgSize = 8;
257 GV.EIP_++;
258 FillFlags(pMyDisasm, 76);
259}
260
261/* =======================================
262 * 06fh
263 * ======================================= */
264void __bea_callspec__ outsw_(PDISASM pMyDisasm)
265{
266 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
267 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
268 }
269 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
270 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
271 }
272 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
273 if (GV.OperandSize >= 32) {
274 #ifndef BEA_LIGHT_DISASSEMBLY
275 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "outsd ");
276 #endif
277 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
278 (*pMyDisasm).Argument1.ArgSize = 16;
279 (*pMyDisasm).Argument1.AccessMode = READ;
280 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
281 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
282 (*pMyDisasm).Argument2.ArgSize = 32;
283 GV.EIP_++;
284 FillFlags(pMyDisasm, 76);
285 }
286
287 else {
288 #ifndef BEA_LIGHT_DISASSEMBLY
289 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "outsw ");
290 #endif
291 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
292 (*pMyDisasm).Argument1.ArgSize = 16;
293 (*pMyDisasm).Argument1.AccessMode = READ;
294 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
295 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
296 (*pMyDisasm).Argument2.ArgSize = 16;
297 GV.EIP_++;
298 FillFlags(pMyDisasm, 76);
299 }
300}
301
302/* =======================================
303 *
304 * ======================================= */
305void __bea_callspec__ out_IbAL(PDISASM pMyDisasm)
306{
307 long MyNumber;
308
309 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
310 #ifndef BEA_LIGHT_DISASSEMBLY
311 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
312 #endif
313 if (!Security(2, pMyDisasm)) return;
314 GV.ImmediatSize = 8;
315 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
316 #ifndef BEA_LIGHT_DISASSEMBLY
317 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic,"%.2X",(Int64) MyNumber);
318 #endif
319 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
320 (*pMyDisasm).Argument1.ArgSize = 8;
321 (*pMyDisasm).Argument1.AccessMode = READ;
322 (*pMyDisasm).Instruction.Immediat = MyNumber;
323 #ifndef BEA_LIGHT_DISASSEMBLY
324 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[0]);
325 #endif
326 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
327 (*pMyDisasm).Argument2.ArgSize = 8;
328 GV.EIP_ += 2;
329}
330
331/* =======================================
332 *
333 * ======================================= */
334void __bea_callspec__ out_Ib_eAX(PDISASM pMyDisasm)
335{
336 long MyNumber;
337
338 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
339 #ifndef BEA_LIGHT_DISASSEMBLY
340 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
341 #endif
342 if (!Security(2, pMyDisasm)) return;
343 GV.ImmediatSize = 8;
344 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
345 #ifndef BEA_LIGHT_DISASSEMBLY
346 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic,"%.2X",(Int64) MyNumber);
347 #endif
348 (*pMyDisasm).Argument1.ArgSize = 8;
349 (*pMyDisasm).Argument1.AccessMode = READ;
350 (*pMyDisasm).Instruction.Immediat = MyNumber;
351 if (GV.OperandSize == 32) {
352 #ifndef BEA_LIGHT_DISASSEMBLY
353 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0]);
354 #endif
355 (*pMyDisasm).Argument2.ArgSize = 32;
356 }
357 else {
358 #ifndef BEA_LIGHT_DISASSEMBLY
359 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0]);
360 #endif
361 (*pMyDisasm).Argument2.ArgSize = 16;
362 }
363 GV.EIP_ += 2;
364}
365
366
367/* =======================================
368 *
369 * ======================================= */
370void __bea_callspec__ out_DXAL(PDISASM pMyDisasm)
371{
372 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
373 #ifndef BEA_LIGHT_DISASSEMBLY
374 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
375 #endif
376 #ifndef BEA_LIGHT_DISASSEMBLY
377 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
378 #endif
379 (*pMyDisasm).Argument1.ArgSize = 16;
380 (*pMyDisasm).Argument1.AccessMode = READ;
381 #ifndef BEA_LIGHT_DISASSEMBLY
382 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[0]);
383 #endif
384 (*pMyDisasm).Argument2.ArgSize = 8;
385 GV.EIP_ ++;
386}
387
388/* =======================================
389 *
390 * ======================================= */
391void __bea_callspec__ out_DXeAX(PDISASM pMyDisasm)
392{
393 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
394 #ifndef BEA_LIGHT_DISASSEMBLY
395 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "out ");
396 #endif
397 #ifndef BEA_LIGHT_DISASSEMBLY
398 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
399 #endif
400 (*pMyDisasm).Argument1.ArgSize = 16;
401 (*pMyDisasm).Argument1.AccessMode = READ;
402 if (GV.OperandSize == 32) {
403 #ifndef BEA_LIGHT_DISASSEMBLY
404 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0]);
405 #endif
406 (*pMyDisasm).Argument2.ArgSize = 32;
407 }
408 else {
409 #ifndef BEA_LIGHT_DISASSEMBLY
410 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0]);
411 #endif
412 (*pMyDisasm).Argument2.ArgSize = 16;
413 }
414 GV.EIP_ ++;
415}
416
417/* =======================================
418 * 8fh
419 * ======================================= */
420void __bea_callspec__ pop_Ev(PDISASM pMyDisasm)
421{
422 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
423 GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
424 if (GV.REGOPCODE == 0) {
425 #ifndef BEA_LIGHT_DISASSEMBLY
426 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
427 #endif
428 if (GV.Architecture == 64) {
429 GV.OperandSize = 64;
430 GV.MemDecoration = Arg1qword;
431 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
432 GV.EIP_ += GV.DECALAGE_EIP+2;
433 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
434 (*pMyDisasm).Argument2.ArgSize = 64;
435 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
436 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
437 }
438 else if (GV.OperandSize == 32) {
439 GV.MemDecoration = Arg1dword;
440 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
441 GV.EIP_ += GV.DECALAGE_EIP+2;
442 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
443 (*pMyDisasm).Argument2.ArgSize = 32;
444 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
445 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
446 }
447 else {
448 GV.MemDecoration = Arg1word;
449 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
450 GV.EIP_ += GV.DECALAGE_EIP+2;
451 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
452 (*pMyDisasm).Argument2.ArgSize = 16;
453 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
454 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
455 }
456 }
457 else {
458 FailDecode(pMyDisasm);
459 }
460}
461
462/* =======================================
463 * 58h
464 * ======================================= */
465void __bea_callspec__ pop_eax(PDISASM pMyDisasm)
466{
467 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
468 #ifndef BEA_LIGHT_DISASSEMBLY
469 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
470 #endif
471 if (GV.Architecture == 64) {
472 if (GV.REX.B_ == 0) {
473 #ifndef BEA_LIGHT_DISASSEMBLY
474 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
475 #endif
476 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
477 }
478 else {
479 #ifndef BEA_LIGHT_DISASSEMBLY
480 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0+8]);
481 #endif
482 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0+8];
483 }
484 (*pMyDisasm).Argument1.ArgSize = 64;
485 (*pMyDisasm).Argument2.ArgSize = 64;
486 }
487 else {
488 if (GV.OperandSize == 32) {
489 #ifndef BEA_LIGHT_DISASSEMBLY
490 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
491 #endif
492 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
493 (*pMyDisasm).Argument1.ArgSize = 32;
494 (*pMyDisasm).Argument2.ArgSize = 32;
495 }
496 else {
497 #ifndef BEA_LIGHT_DISASSEMBLY
498 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
499 #endif
500 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
501 (*pMyDisasm).Argument1.ArgSize = 16;
502 (*pMyDisasm).Argument2.ArgSize = 16;
503 }
504 }
505 GV.EIP_++;
506 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
507 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
508 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
509}
510
511/* =======================================
512 * 59h
513 * ======================================= */
514void __bea_callspec__ pop_ecx(PDISASM pMyDisasm)
515{
516 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
517 #ifndef BEA_LIGHT_DISASSEMBLY
518 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
519 #endif
520 if (GV.Architecture == 64) {
521 if (GV.REX.B_ == 0) {
522 #ifndef BEA_LIGHT_DISASSEMBLY
523 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+0]);
524 #endif
525 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
526 }
527 else {
528 #ifndef BEA_LIGHT_DISASSEMBLY
529 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+0+8]);
530 #endif
531 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+8];
532 }
533 (*pMyDisasm).Argument1.ArgSize = 64;
534 (*pMyDisasm).Argument2.ArgSize = 64;
535 }
536 else {
537 if (GV.OperandSize == 32) {
538 #ifndef BEA_LIGHT_DISASSEMBLY
539 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1+0]);
540 #endif
541 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
542 (*pMyDisasm).Argument1.ArgSize = 32;
543 (*pMyDisasm).Argument2.ArgSize = 32;
544 }
545 else {
546 #ifndef BEA_LIGHT_DISASSEMBLY
547 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1+0]);
548 #endif
549 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
550 (*pMyDisasm).Argument1.ArgSize = 16;
551 (*pMyDisasm).Argument2.ArgSize = 16;
552 }
553 }
554 GV.EIP_++;
555 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
556 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
557 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
558}
559
560/* =======================================
561 * 5ah
562 * ======================================= */
563void __bea_callspec__ pop_edx(PDISASM pMyDisasm)
564{
565 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
566 #ifndef BEA_LIGHT_DISASSEMBLY
567 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
568 #endif
569 if (GV.Architecture == 64) {
570 if (GV.REX.B_ == 0) {
571 #ifndef BEA_LIGHT_DISASSEMBLY
572 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+0]);
573 #endif
574 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
575
576 }
577 else {
578 #ifndef BEA_LIGHT_DISASSEMBLY
579 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+0+8]);
580 #endif
581 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+8];
582 }
583 (*pMyDisasm).Argument1.ArgSize = 64;
584 (*pMyDisasm).Argument2.ArgSize = 64;
585 }
586 else {
587 if (GV.OperandSize == 32) {
588 #ifndef BEA_LIGHT_DISASSEMBLY
589 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2+0]);
590 #endif
591 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
592 (*pMyDisasm).Argument1.ArgSize = 32;
593 (*pMyDisasm).Argument2.ArgSize = 32;
594 }
595 else {
596 #ifndef BEA_LIGHT_DISASSEMBLY
597 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2+0]);
598 #endif
599 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
600 (*pMyDisasm).Argument1.ArgSize = 16;
601 (*pMyDisasm).Argument2.ArgSize = 16;
602 }
603 }
604 GV.EIP_++;
605 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
606 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
607 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
608}
609
610/* =======================================
611 * 5bh
612 * ======================================= */
613void __bea_callspec__ pop_ebx(PDISASM pMyDisasm)
614{
615 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
616 #ifndef BEA_LIGHT_DISASSEMBLY
617 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
618 #endif
619 if (GV.Architecture == 64) {
620 if (GV.REX.B_ == 0) {
621 #ifndef BEA_LIGHT_DISASSEMBLY
622 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+0]);
623 #endif
624 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
625 }
626 else {
627 #ifndef BEA_LIGHT_DISASSEMBLY
628 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+0+8]);
629 #endif
630 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+8];
631 }
632 (*pMyDisasm).Argument1.ArgSize = 64;
633 (*pMyDisasm).Argument2.ArgSize = 64;
634 }
635 else {
636 if (GV.OperandSize == 32) {
637 #ifndef BEA_LIGHT_DISASSEMBLY
638 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3+0]);
639 #endif
640 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
641 (*pMyDisasm).Argument1.ArgSize = 32;
642 (*pMyDisasm).Argument2.ArgSize = 32;
643 }
644 else {
645 #ifndef BEA_LIGHT_DISASSEMBLY
646 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3+0]);
647 #endif
648 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
649 (*pMyDisasm).Argument1.ArgSize = 16;
650 (*pMyDisasm).Argument2.ArgSize = 16;
651 }
652 }
653 GV.EIP_++;
654 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
655 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
656 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
657}
658
659/* =======================================
660 * 5ch
661 * ======================================= */
662void __bea_callspec__ pop_esp(PDISASM pMyDisasm)
663{
664 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
665 #ifndef BEA_LIGHT_DISASSEMBLY
666 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
667 #endif
668 if (GV.Architecture == 64) {
669 if (GV.REX.B_ == 0) {
670 #ifndef BEA_LIGHT_DISASSEMBLY
671 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+0]);
672 #endif
673 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
674 }
675 else {
676 #ifndef BEA_LIGHT_DISASSEMBLY
677 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+0+8]);
678 #endif
679 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+8];
680 }
681 (*pMyDisasm).Argument1.ArgSize = 64;
682 (*pMyDisasm).Argument2.ArgSize = 64;
683 }
684 else {
685 if (GV.OperandSize == 32) {
686 #ifndef BEA_LIGHT_DISASSEMBLY
687 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4+0]);
688 #endif
689 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
690 (*pMyDisasm).Argument1.ArgSize = 32;
691 (*pMyDisasm).Argument2.ArgSize = 32;
692 }
693 else {
694 #ifndef BEA_LIGHT_DISASSEMBLY
695 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4+0]);
696 #endif
697 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
698 (*pMyDisasm).Argument1.ArgSize = 16;
699 (*pMyDisasm).Argument2.ArgSize = 16;
700 }
701 }
702 GV.EIP_++;
703 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
704 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
705 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
706}
707
708/* =======================================
709 * 5dh
710 * ======================================= */
711void __bea_callspec__ pop_ebp(PDISASM pMyDisasm)
712{
713 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
714 #ifndef BEA_LIGHT_DISASSEMBLY
715 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
716 #endif
717 if (GV.Architecture == 64) {
718 if (GV.REX.B_ == 0) {
719 #ifndef BEA_LIGHT_DISASSEMBLY
720 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+0]);
721 #endif
722 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
723 }
724 else {
725 #ifndef BEA_LIGHT_DISASSEMBLY
726 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+0+8]);
727 #endif
728 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+8];
729 }
730 (*pMyDisasm).Argument1.ArgSize = 64;
731 (*pMyDisasm).Argument2.ArgSize = 64;
732 }
733 else {
734 if (GV.OperandSize == 32) {
735 #ifndef BEA_LIGHT_DISASSEMBLY
736 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5+0]);
737 #endif
738 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
739 (*pMyDisasm).Argument1.ArgSize = 32;
740 (*pMyDisasm).Argument2.ArgSize = 32;
741 }
742 else {
743 #ifndef BEA_LIGHT_DISASSEMBLY
744 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5+0]);
745 #endif
746 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
747 (*pMyDisasm).Argument1.ArgSize = 16;
748 (*pMyDisasm).Argument2.ArgSize = 16;
749 }
750 }
751 GV.EIP_++;
752 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
753 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
754 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
755}
756
757/* =======================================
758 * 5eh
759 * ======================================= */
760void __bea_callspec__ pop_esi(PDISASM pMyDisasm)
761{
762 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
763 #ifndef BEA_LIGHT_DISASSEMBLY
764 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
765 #endif
766 if (GV.Architecture == 64) {
767 if (GV.REX.B_ == 0) {
768 #ifndef BEA_LIGHT_DISASSEMBLY
769 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+0]);
770 #endif
771 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
772 }
773 else {
774 #ifndef BEA_LIGHT_DISASSEMBLY
775 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+0+8]);
776 #endif
777 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+8];
778 }
779 (*pMyDisasm).Argument1.ArgSize = 64;
780 (*pMyDisasm).Argument2.ArgSize = 64;
781 }
782 else {
783 if (GV.OperandSize == 32) {
784 #ifndef BEA_LIGHT_DISASSEMBLY
785 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6+0]);
786 #endif
787 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
788 (*pMyDisasm).Argument1.ArgSize = 32;
789 (*pMyDisasm).Argument2.ArgSize = 32;
790 }
791 else {
792 #ifndef BEA_LIGHT_DISASSEMBLY
793 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6+0]);
794 #endif
795 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
796 (*pMyDisasm).Argument1.ArgSize = 16;
797 (*pMyDisasm).Argument2.ArgSize = 16;
798 }
799 }
800 GV.EIP_++;
801 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
802 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
803 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
804}
805
806/* =======================================
807 * 5fh
808 * ======================================= */
809void __bea_callspec__ pop_edi(PDISASM pMyDisasm)
810{
811 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
812 #ifndef BEA_LIGHT_DISASSEMBLY
813 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
814 #endif
815 if (GV.Architecture == 64) {
816 if (GV.REX.B_ == 0) {
817 #ifndef BEA_LIGHT_DISASSEMBLY
818 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+0]);
819 #endif
820 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
821 }
822 else {
823 #ifndef BEA_LIGHT_DISASSEMBLY
824 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+0+8]);
825 #endif
826 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+8];
827 }
828 (*pMyDisasm).Argument1.ArgSize = 64;
829 (*pMyDisasm).Argument2.ArgSize = 64;
830 }
831 else {
832 if (GV.OperandSize == 32) {
833 #ifndef BEA_LIGHT_DISASSEMBLY
834 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7+0]);
835 #endif
836 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
837 (*pMyDisasm).Argument1.ArgSize = 32;
838 (*pMyDisasm).Argument2.ArgSize = 32;
839 }
840 else {
841 #ifndef BEA_LIGHT_DISASSEMBLY
842 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7+0]);
843 #endif
844 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
845 (*pMyDisasm).Argument1.ArgSize = 16;
846 (*pMyDisasm).Argument2.ArgSize = 16;
847 }
848 }
849 GV.EIP_++;
850 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
851 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
852 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
853}
854
855/* =======================================
856 *
857 * ======================================= */
858void __bea_callspec__ pop_es(PDISASM pMyDisasm)
859{
860 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
861 #ifndef BEA_LIGHT_DISASSEMBLY
862 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
863 #endif
864 if (GV.Architecture == 64) {
865 FailDecode(pMyDisasm);
866 }
867 else {
868 #ifndef BEA_LIGHT_DISASSEMBLY
869 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[0]);
870 #endif
871 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[0];
872 (*pMyDisasm).Argument1.ArgSize = 16;
873 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
874 (*pMyDisasm).Argument2.ArgSize = 16;
875 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
876 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
877 GV.EIP_++;
878 }
879}
880
881/* =======================================
882 *
883 * ======================================= */
884void __bea_callspec__ pop_ss(PDISASM pMyDisasm)
885{
886 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
887 #ifndef BEA_LIGHT_DISASSEMBLY
888 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
889 #endif
890 if (GV.Architecture == 64) {
891 FailDecode(pMyDisasm);
892 }
893 else {
894 #ifndef BEA_LIGHT_DISASSEMBLY
895 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[2]);
896 #endif
897 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[2];
898 (*pMyDisasm).Argument1.ArgSize = 16;
899 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
900 (*pMyDisasm).Argument2.ArgSize = 16;
901 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
902 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
903 GV.EIP_++;
904 }
905}
906
907/* =======================================
908 *
909 * ======================================= */
910void __bea_callspec__ pop_ds(PDISASM pMyDisasm)
911{
912 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
913 #ifndef BEA_LIGHT_DISASSEMBLY
914 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
915 #endif
916 if (GV.Architecture == 64) {
917 FailDecode(pMyDisasm);
918 }
919 else {
920 #ifndef BEA_LIGHT_DISASSEMBLY
921 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[3]);
922 #endif
923 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[3];
924 (*pMyDisasm).Argument1.ArgSize = 16;
925 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
926 (*pMyDisasm).Argument2.ArgSize = 16;
927 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
928 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
929 GV.EIP_++;
930 }
931}
932
933/* =======================================
934 *
935 * ======================================= */
936void __bea_callspec__ pop_fs(PDISASM pMyDisasm)
937{
938 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
939 #ifndef BEA_LIGHT_DISASSEMBLY
940 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
941 #endif
942 if (GV.Architecture == 64) {
943 FailDecode(pMyDisasm);
944 }
945 else {
946 #ifndef BEA_LIGHT_DISASSEMBLY
947 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[4]);
948 #endif
949 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[4];
950 (*pMyDisasm).Argument1.ArgSize = 16;
951 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
952 (*pMyDisasm).Argument2.ArgSize = 16;
953 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
954 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
955 GV.EIP_++;
956 }
957}
958
959/* =======================================
960 *
961 * ======================================= */
962void __bea_callspec__ pop_gs(PDISASM pMyDisasm)
963{
964 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
965 #ifndef BEA_LIGHT_DISASSEMBLY
966 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pop ");
967 #endif
968 if (GV.Architecture == 64) {
969 FailDecode(pMyDisasm);
970 }
971 else {
972 #ifndef BEA_LIGHT_DISASSEMBLY
973 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[5]);
974 #endif
975 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[5];
976 (*pMyDisasm).Argument1.ArgSize = 16;
977 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
978 (*pMyDisasm).Argument2.ArgSize = 16;
979 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
980 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
981 GV.EIP_++;
982 }
983}
984
985/* =======================================
986 * 9dh
987 * ======================================= */
988void __bea_callspec__ popfd_(PDISASM pMyDisasm)
989{
990 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
991
992 if (GV.Architecture == 64) {
993 #ifndef BEA_LIGHT_DISASSEMBLY
994 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popfq ");
995 #endif
996 GV.EIP_++;
997 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
998 (*pMyDisasm).Argument1.ArgSize = 64;
999 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1000 (*pMyDisasm).Argument2.ArgSize = 64;
1001 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1002 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1003 FillFlags(pMyDisasm, 78);
1004 }
1005 else if (GV.OperandSize == 32) {
1006 #ifndef BEA_LIGHT_DISASSEMBLY
1007 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popfd ");
1008 #endif
1009 GV.EIP_++;
1010 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1011 (*pMyDisasm).Argument1.ArgSize = 32;
1012 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1013 (*pMyDisasm).Argument2.ArgSize = 32;
1014 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1015 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1016 FillFlags(pMyDisasm, 78);
1017 }
1018 else {
1019 #ifndef BEA_LIGHT_DISASSEMBLY
1020 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popf ");
1021 #endif
1022 GV.EIP_++;
1023 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1024 (*pMyDisasm).Argument1.ArgSize = 16;
1025 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1026 (*pMyDisasm).Argument2.ArgSize = 16;
1027 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1028 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1029 FillFlags(pMyDisasm, 78);
1030 }
1031}
1032
1033/* =======================================
1034 * 9dh
1035 * ======================================= */
1036void __bea_callspec__ popad_(PDISASM pMyDisasm)
1037{
1038 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1039
1040 if (GV.Architecture == 64) {
1041 FailDecode(pMyDisasm);
1042 }
1043 else if (GV.OperandSize == 32) {
1044 #ifndef BEA_LIGHT_DISASSEMBLY
1045 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popad ");
1046 #endif
1047 GV.EIP_++;
1048 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2+REG3+REG4+REG5+REG6+REG7;
1049 (*pMyDisasm).Argument1.ArgSize = 32;
1050 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1051 (*pMyDisasm).Argument2.ArgSize = 32;
1052 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1053 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1054 }
1055 else {
1056 #ifndef BEA_LIGHT_DISASSEMBLY
1057 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popa ");
1058 #endif
1059 GV.EIP_++;
1060 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2+REG3+REG4+REG5+REG6+REG7;
1061 (*pMyDisasm).Argument1.ArgSize = 16;
1062 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1063 (*pMyDisasm).Argument2.ArgSize = 16;
1064 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1065 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1066 }
1067}
1068
1069
1070/* =======================================
1071 *
1072 * ======================================= */
1073void __bea_callspec__ push_es(PDISASM pMyDisasm)
1074{
1075 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1076 #ifndef BEA_LIGHT_DISASSEMBLY
1077 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1078 #endif
1079 if (GV.Architecture == 64) {
1080 FailDecode(pMyDisasm);
1081 }
1082 else {
1083 #ifndef BEA_LIGHT_DISASSEMBLY
1084 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[0]);
1085 #endif
1086 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[0];
1087 (*pMyDisasm).Argument2.ArgSize = 16;
1088 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1089 (*pMyDisasm).Argument1.ArgSize = 16;
1090 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1091 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1092 GV.EIP_++;
1093 }
1094}
1095
1096/* =======================================
1097 *
1098 * ======================================= */
1099void __bea_callspec__ push_ss(PDISASM pMyDisasm)
1100{
1101 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1102 #ifndef BEA_LIGHT_DISASSEMBLY
1103 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1104 #endif
1105 if (GV.Architecture == 64) {
1106 FailDecode(pMyDisasm);
1107 }
1108 else {
1109 #ifndef BEA_LIGHT_DISASSEMBLY
1110 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[2]);
1111 #endif
1112 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[2];
1113 (*pMyDisasm).Argument2.ArgSize = 16;
1114 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1115 (*pMyDisasm).Argument1.ArgSize = 16;
1116 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1117 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1118 GV.EIP_++;
1119 }
1120}
1121
1122/* =======================================
1123 *
1124 * ======================================= */
1125void __bea_callspec__ push_ds(PDISASM pMyDisasm)
1126{
1127 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1128 #ifndef BEA_LIGHT_DISASSEMBLY
1129 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1130 #endif
1131 if (GV.Architecture == 64) {
1132 FailDecode(pMyDisasm);
1133 }
1134 else {
1135 #ifndef BEA_LIGHT_DISASSEMBLY
1136 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[3]);
1137 #endif
1138 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[3];
1139 (*pMyDisasm).Argument2.ArgSize = 16;
1140 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1141 (*pMyDisasm).Argument1.ArgSize = 16;
1142 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1143 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1144 GV.EIP_++;
1145 }
1146}
1147
1148/* =======================================
1149 *
1150 * ======================================= */
1151void __bea_callspec__ push_fs(PDISASM pMyDisasm)
1152{
1153 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1154 #ifndef BEA_LIGHT_DISASSEMBLY
1155 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1156 #endif
1157 if (GV.Architecture == 64) {
1158 FailDecode(pMyDisasm);
1159 }
1160 else {
1161 #ifndef BEA_LIGHT_DISASSEMBLY
1162 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[4]);
1163 #endif
1164 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[4];
1165 (*pMyDisasm).Argument2.ArgSize = 16;
1166 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1167 (*pMyDisasm).Argument1.ArgSize = 16;
1168 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1169 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1170 GV.EIP_++;
1171 }
1172}
1173
1174/* =======================================
1175 *
1176 * ======================================= */
1177void __bea_callspec__ push_gs(PDISASM pMyDisasm)
1178{
1179 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1180 #ifndef BEA_LIGHT_DISASSEMBLY
1181 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1182 #endif
1183 if (GV.Architecture == 64) {
1184 FailDecode(pMyDisasm);
1185 }
1186 else {
1187 #ifndef BEA_LIGHT_DISASSEMBLY
1188 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[5]);
1189 #endif
1190 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[5];
1191 (*pMyDisasm).Argument2.ArgSize = 16;
1192 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1193 (*pMyDisasm).Argument1.ArgSize = 16;
1194 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1195 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1196 GV.EIP_++;
1197 }
1198}
1199
1200/* =======================================
1201 *
1202 * ======================================= */
1203void __bea_callspec__ push_cs(PDISASM pMyDisasm)
1204{
1205 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1206 #ifndef BEA_LIGHT_DISASSEMBLY
1207 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1208 #endif
1209 if (GV.Architecture == 64) {
1210 FailDecode(pMyDisasm);
1211 }
1212 else {
1213 #ifndef BEA_LIGHT_DISASSEMBLY
1214 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, RegistersSEG[1]);
1215 #endif
1216 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SEGMENT_REG+REGS[1];
1217 (*pMyDisasm).Argument2.ArgSize = 16;
1218 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1219 (*pMyDisasm).Argument1.ArgSize = 16;
1220 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1221 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1222 GV.EIP_++;
1223 }
1224}
1225
1226
1227
1228/* =======================================
1229 * 50h
1230 * ======================================= */
1231void __bea_callspec__ push_eax(PDISASM pMyDisasm)
1232{
1233 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1234 #ifndef BEA_LIGHT_DISASSEMBLY
1235 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1236 #endif
1237 if (GV.Architecture == 64) {
1238 if (GV.REX.B_ == 0) {
1239 #ifndef BEA_LIGHT_DISASSEMBLY
1240 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[0]);
1241 #endif
1242 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
1243 }
1244 else {
1245 #ifndef BEA_LIGHT_DISASSEMBLY
1246 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[0+8]);
1247 #endif
1248 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0+8];
1249 }
1250 (*pMyDisasm).Argument2.ArgSize = 64;
1251 (*pMyDisasm).Argument1.ArgSize = 64;
1252 }
1253 else {
1254 if (GV.OperandSize == 32) {
1255 #ifndef BEA_LIGHT_DISASSEMBLY
1256 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0]);
1257 #endif
1258 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
1259 (*pMyDisasm).Argument2.ArgSize = 32;
1260 (*pMyDisasm).Argument1.ArgSize = 32;
1261 }
1262 else {
1263 #ifndef BEA_LIGHT_DISASSEMBLY
1264 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0]);
1265 #endif
1266 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
1267 (*pMyDisasm).Argument2.ArgSize = 16;
1268 (*pMyDisasm).Argument1.ArgSize = 16;
1269 }
1270 }
1271 GV.EIP_++;
1272 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1273 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1274 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1275}
1276
1277/* =======================================
1278 * 51h
1279 * ======================================= */
1280void __bea_callspec__ push_ecx(PDISASM pMyDisasm)
1281{
1282 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1283 #ifndef BEA_LIGHT_DISASSEMBLY
1284 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1285 #endif
1286 if (GV.Architecture == 64) {
1287 if (GV.REX.B_ == 0) {
1288 #ifndef BEA_LIGHT_DISASSEMBLY
1289 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[1+0]);
1290 #endif
1291 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
1292 }
1293 else {
1294 #ifndef BEA_LIGHT_DISASSEMBLY
1295 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[1+0+8]);
1296 #endif
1297 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+8];
1298 }
1299 (*pMyDisasm).Argument2.ArgSize = 64;
1300 (*pMyDisasm).Argument1.ArgSize = 64;
1301 }
1302 else {
1303 if (GV.OperandSize == 32) {
1304 #ifndef BEA_LIGHT_DISASSEMBLY
1305 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[1+0]);
1306 #endif
1307 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
1308 (*pMyDisasm).Argument2.ArgSize = 32;
1309 (*pMyDisasm).Argument1.ArgSize = 32;
1310 }
1311 else {
1312 #ifndef BEA_LIGHT_DISASSEMBLY
1313 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[1+0]);
1314 #endif
1315 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1];
1316 (*pMyDisasm).Argument2.ArgSize = 16;
1317 (*pMyDisasm).Argument1.ArgSize = 16;
1318 }
1319 }
1320 GV.EIP_++;
1321 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1322 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1323 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1324}
1325
1326/* =======================================
1327 * 52h
1328 * ======================================= */
1329void __bea_callspec__ push_edx(PDISASM pMyDisasm)
1330{
1331 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1332 #ifndef BEA_LIGHT_DISASSEMBLY
1333 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1334 #endif
1335 if (GV.Architecture == 64) {
1336 if (GV.REX.B_ == 0) {
1337 #ifndef BEA_LIGHT_DISASSEMBLY
1338 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[2+0]);
1339 #endif
1340 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
1341
1342 }
1343 else {
1344 #ifndef BEA_LIGHT_DISASSEMBLY
1345 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[2+0+8]);
1346 #endif
1347 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+8];
1348 }
1349 (*pMyDisasm).Argument2.ArgSize = 64;
1350 (*pMyDisasm).Argument1.ArgSize = 64;
1351 }
1352 else {
1353 if (GV.OperandSize == 32) {
1354 #ifndef BEA_LIGHT_DISASSEMBLY
1355 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[2+0]);
1356 #endif
1357 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
1358 (*pMyDisasm).Argument2.ArgSize = 32;
1359 (*pMyDisasm).Argument1.ArgSize = 32;
1360 }
1361 else {
1362 #ifndef BEA_LIGHT_DISASSEMBLY
1363 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2+0]);
1364 #endif
1365 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
1366 (*pMyDisasm).Argument2.ArgSize = 16;
1367 (*pMyDisasm).Argument1.ArgSize = 16;
1368 }
1369 }
1370 GV.EIP_++;
1371 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1372 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1373 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1374}
1375
1376/* =======================================
1377 * 53h
1378 * ======================================= */
1379void __bea_callspec__ push_ebx(PDISASM pMyDisasm)
1380{
1381 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1382 #ifndef BEA_LIGHT_DISASSEMBLY
1383 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1384 #endif
1385 if (GV.Architecture == 64) {
1386 if (GV.REX.B_ == 0) {
1387 #ifndef BEA_LIGHT_DISASSEMBLY
1388 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[3+0]);
1389 #endif
1390 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
1391 }
1392 else {
1393 #ifndef BEA_LIGHT_DISASSEMBLY
1394 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[3+0+8]);
1395 #endif
1396 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+8];
1397 }
1398 (*pMyDisasm).Argument2.ArgSize = 64;
1399 (*pMyDisasm).Argument1.ArgSize = 64;
1400 }
1401 else {
1402 if (GV.OperandSize == 32) {
1403 #ifndef BEA_LIGHT_DISASSEMBLY
1404 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[3+0]);
1405 #endif
1406 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
1407 (*pMyDisasm).Argument2.ArgSize = 32;
1408 (*pMyDisasm).Argument1.ArgSize = 32;
1409 }
1410 else {
1411 #ifndef BEA_LIGHT_DISASSEMBLY
1412 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[3+0]);
1413 #endif
1414 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3];
1415 (*pMyDisasm).Argument2.ArgSize = 16;
1416 (*pMyDisasm).Argument1.ArgSize = 16;
1417 }
1418 }
1419 GV.EIP_++;
1420 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1421 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1422 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1423}
1424
1425/* =======================================
1426 * 54h
1427 * ======================================= */
1428void __bea_callspec__ push_esp(PDISASM pMyDisasm)
1429{
1430 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1431 #ifndef BEA_LIGHT_DISASSEMBLY
1432 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1433 #endif
1434 if (GV.Architecture == 64) {
1435 if (GV.REX.B_ == 0) {
1436 #ifndef BEA_LIGHT_DISASSEMBLY
1437 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[4+0]);
1438 #endif
1439 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
1440 }
1441 else {
1442 #ifndef BEA_LIGHT_DISASSEMBLY
1443 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[4+0+8]);
1444 #endif
1445 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+8];
1446 }
1447 (*pMyDisasm).Argument2.ArgSize = 64;
1448 (*pMyDisasm).Argument1.ArgSize = 64;
1449 }
1450 else {
1451 if (GV.OperandSize == 32) {
1452 #ifndef BEA_LIGHT_DISASSEMBLY
1453 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[4+0]);
1454 #endif
1455 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
1456 (*pMyDisasm).Argument2.ArgSize = 32;
1457 (*pMyDisasm).Argument1.ArgSize = 32;
1458 }
1459 else {
1460 #ifndef BEA_LIGHT_DISASSEMBLY
1461 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[4+0]);
1462 #endif
1463 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4];
1464 (*pMyDisasm).Argument2.ArgSize = 16;
1465 (*pMyDisasm).Argument1.ArgSize = 16;
1466 }
1467 }
1468 GV.EIP_++;
1469 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1470 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1471 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1472}
1473
1474/* =======================================
1475 * 55h
1476 * ======================================= */
1477void __bea_callspec__ push_ebp(PDISASM pMyDisasm)
1478{
1479 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1480 #ifndef BEA_LIGHT_DISASSEMBLY
1481 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1482 #endif
1483 if (GV.Architecture == 64) {
1484 if (GV.REX.B_ == 0) {
1485 #ifndef BEA_LIGHT_DISASSEMBLY
1486 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[5+0]);
1487 #endif
1488 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
1489 }
1490 else {
1491 #ifndef BEA_LIGHT_DISASSEMBLY
1492 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[5+0+8]);
1493 #endif
1494 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+8];
1495 }
1496 (*pMyDisasm).Argument2.ArgSize = 64;
1497 (*pMyDisasm).Argument1.ArgSize = 64;
1498 }
1499 else {
1500 if (GV.OperandSize == 32) {
1501 #ifndef BEA_LIGHT_DISASSEMBLY
1502 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[5+0]);
1503 #endif
1504 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
1505 (*pMyDisasm).Argument2.ArgSize = 32;
1506 (*pMyDisasm).Argument1.ArgSize = 32;
1507 }
1508 else {
1509 #ifndef BEA_LIGHT_DISASSEMBLY
1510 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[5+0]);
1511 #endif
1512 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5];
1513 (*pMyDisasm).Argument2.ArgSize = 16;
1514 (*pMyDisasm).Argument1.ArgSize = 16;
1515 }
1516 }
1517 GV.EIP_++;
1518 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1519 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1520 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1521}
1522
1523/* =======================================
1524 * 56h
1525 * ======================================= */
1526void __bea_callspec__ push_esi(PDISASM pMyDisasm)
1527{
1528 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1529 #ifndef BEA_LIGHT_DISASSEMBLY
1530 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1531 #endif
1532 if (GV.Architecture == 64) {
1533 if (GV.REX.B_ == 0) {
1534 #ifndef BEA_LIGHT_DISASSEMBLY
1535 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[6+0]);
1536 #endif
1537 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
1538 }
1539 else {
1540 #ifndef BEA_LIGHT_DISASSEMBLY
1541 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[6+0+8]);
1542 #endif
1543 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+8];
1544 }
1545 (*pMyDisasm).Argument2.ArgSize = 64;
1546 (*pMyDisasm).Argument1.ArgSize = 64;
1547 }
1548 else {
1549 if (GV.OperandSize == 32) {
1550 #ifndef BEA_LIGHT_DISASSEMBLY
1551 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[6+0]);
1552 #endif
1553 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
1554 (*pMyDisasm).Argument2.ArgSize = 32;
1555 (*pMyDisasm).Argument1.ArgSize = 32;
1556 }
1557 else {
1558 #ifndef BEA_LIGHT_DISASSEMBLY
1559 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[6+0]);
1560 #endif
1561 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6];
1562 (*pMyDisasm).Argument2.ArgSize = 16;
1563 (*pMyDisasm).Argument1.ArgSize = 16;
1564 }
1565 }
1566 GV.EIP_++;
1567 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1568 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1569 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1570}
1571
1572/* =======================================
1573 * 57h
1574 * ======================================= */
1575void __bea_callspec__ push_edi(PDISASM pMyDisasm)
1576{
1577 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1578 #ifndef BEA_LIGHT_DISASSEMBLY
1579 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1580 #endif
1581 if (GV.Architecture == 64) {
1582 if (GV.REX.B_ == 0) {
1583 #ifndef BEA_LIGHT_DISASSEMBLY
1584 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[7+0]);
1585 #endif
1586 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
1587 }
1588 else {
1589 #ifndef BEA_LIGHT_DISASSEMBLY
1590 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[7+0+8]);
1591 #endif
1592 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+8];
1593 }
1594 (*pMyDisasm).Argument2.ArgSize = 64;
1595 (*pMyDisasm).Argument1.ArgSize = 64;
1596 }
1597 else {
1598 if (GV.OperandSize == 32) {
1599 #ifndef BEA_LIGHT_DISASSEMBLY
1600 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[7+0]);
1601 #endif
1602 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
1603 (*pMyDisasm).Argument2.ArgSize = 32;
1604 (*pMyDisasm).Argument1.ArgSize = 32;
1605 }
1606 else {
1607 #ifndef BEA_LIGHT_DISASSEMBLY
1608 (void) strcpy((char*) &(*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[7+0]);
1609 #endif
1610 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7];
1611 (*pMyDisasm).Argument2.ArgSize = 16;
1612 (*pMyDisasm).Argument1.ArgSize = 16;
1613 }
1614 }
1615 GV.EIP_++;
1616 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1617 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1618 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1619}
1620
1621
1622/* =======================================
1623 * 68h
1624 * ======================================= */
1625void __bea_callspec__ push_Iv(PDISASM pMyDisasm)
1626{
1627 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1628
1629 #ifndef BEA_LIGHT_DISASSEMBLY
1630 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1631 #endif
1632 if (GV.Architecture == 64) {
1633 if (!Security(5, pMyDisasm)) return;
1634 #ifndef BEA_LIGHT_DISASSEMBLY
1635 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.8X",(Int64)*((UInt32*)(UIntPtr) (GV.EIP_+1)));
1636 #endif
1637 GV.ImmediatSize = 32;
1638 (*pMyDisasm).Instruction.Immediat = *((UInt32*)(UIntPtr) (GV.EIP_+1));
1639 GV.EIP_ += 5;
1640 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1641 (*pMyDisasm).Argument1.ArgSize = 64;
1642 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1643 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1644 (*pMyDisasm).Argument2.ArgSize = 64;
1645 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1646 }
1647 else if (GV.OperandSize == 32) {
1648 if (!Security(5, pMyDisasm)) return;
1649 #ifndef BEA_LIGHT_DISASSEMBLY
1650 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.8X",(Int64)*((UInt32*)(UIntPtr) (GV.EIP_+1)));
1651 #endif
1652 GV.ImmediatSize = 32;
1653 (*pMyDisasm).Instruction.Immediat = *((UInt32*)(UIntPtr) (GV.EIP_+1));
1654 GV.EIP_ += 5;
1655 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1656 (*pMyDisasm).Argument1.ArgSize = 32;
1657 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1658 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1659 (*pMyDisasm).Argument2.ArgSize = 32;
1660 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1661 }
1662 else {
1663 if (!Security(3, pMyDisasm)) return;
1664 #ifndef BEA_LIGHT_DISASSEMBLY
1665 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.4X",(Int64)*((UInt16*)(UIntPtr) (GV.EIP_+1)));
1666 #endif
1667 GV.ImmediatSize = 16;
1668 (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_+1));
1669 GV.EIP_ += 3;
1670 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1671 (*pMyDisasm).Argument1.ArgSize = 16;
1672 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1673 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1674 (*pMyDisasm).Argument2.ArgSize = 16;
1675 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1676 }
1677}
1678
1679/* =======================================
1680 * 6ah
1681 * ======================================= */
1682void __bea_callspec__ push_Ib(PDISASM pMyDisasm)
1683{
1684 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1685 #ifndef BEA_LIGHT_DISASSEMBLY
1686 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "push ");
1687 #endif
1688 if (!Security(1, pMyDisasm)) return;
1689 #ifndef BEA_LIGHT_DISASSEMBLY
1690 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.8X",(Int64)*((Int8*)(IntPtr) (GV.EIP_+1)));
1691 #endif
1692 GV.ImmediatSize = 8;
1693 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_+1));
1694 GV.EIP_ += 2;
1695 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1696 (*pMyDisasm).Argument1.ArgSize = 32;
1697 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1698 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1699 (*pMyDisasm).Argument2.ArgSize = 8;
1700 (*pMyDisasm).Instruction.ImplicitModifiedRegs = REGISTER_TYPE+GENERAL_REG+REG4;
1701
1702}
1703
1704
1705/* =======================================
1706 * 9ch
1707 * ======================================= */
1708void __bea_callspec__ pushfd_(PDISASM pMyDisasm)
1709{
1710 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1711
1712 if (GV.Architecture == 64) {
1713 #ifndef BEA_LIGHT_DISASSEMBLY
1714 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pushfq ");
1715 #endif
1716 GV.EIP_++;
1717 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1718 (*pMyDisasm).Argument2.ArgSize = 64;
1719 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1720 (*pMyDisasm).Argument1.ArgSize = 64;
1721 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1722 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1723 FillFlags(pMyDisasm, 78);
1724 }
1725 else if (GV.OperandSize == 32) {
1726 #ifndef BEA_LIGHT_DISASSEMBLY
1727 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pushfd ");
1728 #endif
1729 GV.EIP_++;
1730 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1731 (*pMyDisasm).Argument2.ArgSize = 32;
1732 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1733 (*pMyDisasm).Argument1.ArgSize = 32;
1734 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1735 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1736 FillFlags(pMyDisasm, 78);
1737 }
1738 else {
1739 #ifndef BEA_LIGHT_DISASSEMBLY
1740 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pushf ");
1741 #endif
1742 GV.EIP_++;
1743 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1744 (*pMyDisasm).Argument2.ArgSize = 16;
1745 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1746 (*pMyDisasm).Argument1.ArgSize = 16;
1747 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1748 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1749 FillFlags(pMyDisasm, 78);
1750 }
1751}
1752
1753
1754/* =======================================
1755 * 60h
1756 * ======================================= */
1757void __bea_callspec__ pushad_(PDISASM pMyDisasm)
1758{
1759 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1760
1761 if (GV.Architecture == 64) {
1762 FailDecode(pMyDisasm);
1763 }
1764 else if (GV.OperandSize == 32) {
1765 #ifndef BEA_LIGHT_DISASSEMBLY
1766 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pushad ");
1767 #endif
1768 GV.EIP_++;
1769 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2+REG3+REG4+REG5+REG6+REG7;
1770 (*pMyDisasm).Argument2.ArgSize = 32;
1771 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1772 (*pMyDisasm).Argument1.ArgSize = 32;
1773 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1774 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1775 }
1776 else {
1777 #ifndef BEA_LIGHT_DISASSEMBLY
1778 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pusha ");
1779 #endif
1780 GV.EIP_++;
1781 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2+REG3+REG4+REG5+REG6+REG7;
1782 (*pMyDisasm).Argument2.ArgSize = 16;
1783 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1784 (*pMyDisasm).Argument1.ArgSize = 16;
1785 (*pMyDisasm).Argument1.Memory.BaseRegister = REG4;
1786 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1787 }
1788}
1789
1790/* =======================================
1791 * 0c2h
1792 * ======================================= */
1793void __bea_callspec__ retn_(PDISASM pMyDisasm)
1794{
1795 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1796 (*pMyDisasm).Instruction.BranchType = RetType;
1797 #ifndef BEA_LIGHT_DISASSEMBLY
1798 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retn ");
1799 #endif
1800 if (!Security(3, pMyDisasm)) return;
1801 #ifndef BEA_LIGHT_DISASSEMBLY
1802 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic,"%.4X",(Int64)*((UInt16*)(UIntPtr) (GV.EIP_+1)));
1803 #endif
1804 GV.ImmediatSize = 16;
1805 (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_+1));
1806 GV.EIP_+=3;
1807 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1808 (*pMyDisasm).Argument1.ArgSize = 16;
1809 (*pMyDisasm).Argument1.AccessMode = READ;
1810 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1811}
1812
1813/* =======================================
1814 * 0c3h
1815 * ======================================= */
1816void __bea_callspec__ ret_(PDISASM pMyDisasm)
1817{
1818 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
1819 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
1820 }
1821 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1822 (*pMyDisasm).Instruction.BranchType = RetType;
1823 #ifndef BEA_LIGHT_DISASSEMBLY
1824 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ret ");
1825 #endif
1826 GV.EIP_++;
1827 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1828 (*pMyDisasm).Argument2.ArgSize = 32;
1829 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1830 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1831}
1832
1833/* =======================================
1834 *
1835 * ======================================= */
1836void __bea_callspec__ retf_(PDISASM pMyDisasm)
1837{
1838 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1839 (*pMyDisasm).Instruction.BranchType = RetType;
1840 if (GV.SYNTAX_ == ATSyntax) {
1841 #ifndef BEA_LIGHT_DISASSEMBLY
1842 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lret ");
1843 #endif
1844 }
1845 else {
1846 #ifndef BEA_LIGHT_DISASSEMBLY
1847 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retf ");
1848 #endif
1849 }
1850 #ifndef BEA_LIGHT_DISASSEMBLY
1851 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retf ");
1852 #endif
1853 GV.EIP_++;
1854 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1855 (*pMyDisasm).Argument2.ArgSize = 32;
1856 (*pMyDisasm).Argument2.Memory.BaseRegister = REG4;
1857 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1858}
1859
1860/* =======================================
1861 *
1862 * ======================================= */
1863void __bea_callspec__ retf_Iw(PDISASM pMyDisasm)
1864{
1865 int i = 0;
1866 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1867 (*pMyDisasm).Instruction.BranchType = RetType;
1868 if (GV.SYNTAX_ == ATSyntax) {
1869 #ifndef BEA_LIGHT_DISASSEMBLY
1870 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lret ");
1871 #endif
1872 }
1873 else {
1874 #ifndef BEA_LIGHT_DISASSEMBLY
1875 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "retf ");
1876 #endif
1877 }
1878 if (!Security(3, pMyDisasm)) return;
1879 #ifndef BEA_LIGHT_DISASSEMBLY
1880 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i,"%.4X",(Int64)*((UInt16*)(UIntPtr) (GV.EIP_+1)));
1881 #endif
1882 GV.ImmediatSize = 16;
1883 (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_+1));
1884 GV.EIP_+=3;
1885 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1886 (*pMyDisasm).Argument1.ArgSize = 16;
1887 (*pMyDisasm).Argument1.AccessMode = READ;
1888 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1889}
1890
1891/* =======================================
1892 *
1893 * ======================================= */
1894void __bea_callspec__ rdtsc_(PDISASM pMyDisasm)
1895{
1896 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1897 #ifndef BEA_LIGHT_DISASSEMBLY
1898 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rdtsc ");
1899 #endif
1900 GV.EIP_++;
1901 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
1902 (*pMyDisasm).Argument1.ArgSize = 32;
1903}
1904
1905/* =======================================
1906 *
1907 * ======================================= */
1908void __bea_callspec__ rdmsr_(PDISASM pMyDisasm)
1909{
1910 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1911 #ifndef BEA_LIGHT_DISASSEMBLY
1912 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rdmsr ");
1913 #endif
1914 GV.EIP_++;
1915 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
1916 (*pMyDisasm).Argument1.ArgSize = 32;
1917 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
1918 (*pMyDisasm).Argument2.ArgSize = 32;
1919}
1920
1921/* =======================================
1922 *
1923 * ======================================= */
1924void __bea_callspec__ rdpmc_(PDISASM pMyDisasm)
1925{
1926 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1927 #ifndef BEA_LIGHT_DISASSEMBLY
1928 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rdpmc ");
1929 #endif
1930 GV.EIP_++;
1931 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
1932 (*pMyDisasm).Argument1.ArgSize = 32;
1933 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
1934 (*pMyDisasm).Argument2.ArgSize = 32;
1935}
1936
1937/* =======================================
1938 *
1939 * ======================================= */
1940void __bea_callspec__ rsm_(PDISASM pMyDisasm)
1941{
1942 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1943 #ifndef BEA_LIGHT_DISASSEMBLY
1944 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rsm ");
1945 #endif
1946 GV.EIP_++;
1947 FillFlags(pMyDisasm, 89);
1948}
1949
1950/* =======================================
1951 *
1952 * ======================================= */
1953void __bea_callspec__ sysenter_(PDISASM pMyDisasm)
1954{
1955 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1956 #ifndef BEA_LIGHT_DISASSEMBLY
1957 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sysenter ");
1958 #endif
1959 GV.EIP_++;
1960}
1961
1962/* =======================================
1963 *
1964 * ======================================= */
1965void __bea_callspec__ sysexit_(PDISASM pMyDisasm)
1966{
1967 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1968 #ifndef BEA_LIGHT_DISASSEMBLY
1969 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sysexit ");
1970 #endif
1971 GV.EIP_++;
1972}
1973
1974/* =======================================
1975 *
1976 * ======================================= */
1977void __bea_callspec__ sahf_(PDISASM pMyDisasm)
1978{
1979 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1980 #ifndef BEA_LIGHT_DISASSEMBLY
1981 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sahf ");
1982 #endif
1983 GV.EIP_++;
1984 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1985 (*pMyDisasm).Argument1.ArgSize = 32;
1986 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
1987 (*pMyDisasm).Argument2.ArgSize = 8;
1988}
1989
1990/* =======================================
1991 *
1992 * ======================================= */
1993void __bea_callspec__ salc_(PDISASM pMyDisasm)
1994{
1995 (*pMyDisasm).Instruction.Category = UNDOCUMENTED_INSTRUCTION;
1996 #ifndef BEA_LIGHT_DISASSEMBLY
1997 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "salc ");
1998 #endif
1999 GV.EIP_++;
2000}
2001
2002
2003/* =======================================
2004 * 0ach
2005 * ======================================= */
2006void __bea_callspec__ scasb_(PDISASM pMyDisasm)
2007{
2008 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2009 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2010 }
2011 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2012 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2013 }
2014 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
2015 #ifndef BEA_LIGHT_DISASSEMBLY
2016 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasb ");
2017 #endif
2018 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2019 (*pMyDisasm).Argument1.ArgSize = 8;
2020 (*pMyDisasm).Argument1.AccessMode = READ;
2021 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
2022 (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
2023 (*pMyDisasm).Argument2.ArgSize = 8;
2024 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2025 GV.EIP_++;
2026 FillFlags(pMyDisasm, 94);
2027}
2028
2029/* =======================================
2030 * 0adh
2031 * ======================================= */
2032void __bea_callspec__ scas_(PDISASM pMyDisasm)
2033{
2034 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2035 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2036 }
2037 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2038 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2039 }
2040 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
2041 if (GV.OperandSize == 64) {
2042 #ifndef BEA_LIGHT_DISASSEMBLY
2043 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasq ");
2044 #endif
2045 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2046 (*pMyDisasm).Argument1.ArgSize = 64;
2047 (*pMyDisasm).Argument1.AccessMode = READ;
2048 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
2049 (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
2050 (*pMyDisasm).Argument2.ArgSize = 64;
2051 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2052 GV.EIP_++;
2053 FillFlags(pMyDisasm, 94);
2054 }
2055 else if (GV.OperandSize == 32) {
2056 #ifndef BEA_LIGHT_DISASSEMBLY
2057 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasd ");
2058 #endif
2059 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2060 (*pMyDisasm).Argument1.ArgSize = 32;
2061 (*pMyDisasm).Argument1.AccessMode = READ;
2062 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
2063 (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
2064 (*pMyDisasm).Argument2.ArgSize = 32;
2065 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2066 GV.EIP_++;
2067 FillFlags(pMyDisasm, 94);
2068 }
2069 else {
2070 #ifndef BEA_LIGHT_DISASSEMBLY
2071 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "scasw ");
2072 #endif
2073 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2074 (*pMyDisasm).Argument1.ArgSize = 16;
2075 (*pMyDisasm).Argument1.AccessMode = READ;
2076 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
2077 (*pMyDisasm).Argument2.Memory.BaseRegister = REG7;
2078 (*pMyDisasm).Argument2.ArgSize = 16;
2079 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2080 GV.EIP_++;
2081 FillFlags(pMyDisasm, 94);
2082 }
2083}
2084
2085/* =======================================
2086 *
2087 * ======================================= */
2088void __bea_callspec__ stc_(PDISASM pMyDisasm)
2089{
2090 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
2091 #ifndef BEA_LIGHT_DISASSEMBLY
2092 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stc ");
2093 #endif
2094 GV.EIP_++;
2095 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
2096 (*pMyDisasm).Argument1.ArgSize = 1;
2097 FillFlags(pMyDisasm, 98);
2098}
2099
2100/* =======================================
2101 *
2102 * ======================================= */
2103void __bea_callspec__ sti_(PDISASM pMyDisasm)
2104{
2105 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
2106 #ifndef BEA_LIGHT_DISASSEMBLY
2107 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sti ");
2108 #endif
2109 GV.EIP_++;
2110 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
2111 (*pMyDisasm).Argument1.ArgSize = 1;
2112 FillFlags(pMyDisasm, 100);
2113}
2114
2115
2116/* =======================================
2117 * 0aah
2118 * ======================================= */
2119void __bea_callspec__ stos_(PDISASM pMyDisasm)
2120{
2121 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2122 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2123 }
2124 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2125 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2126 }
2127 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
2128 #ifndef BEA_LIGHT_DISASSEMBLY
2129 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosb ");
2130 #endif
2131 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2132 (*pMyDisasm).Argument2.ArgSize = 8;
2133 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2134 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2135 (*pMyDisasm).Argument1.ArgSize = 8;
2136 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2137 GV.EIP_++;
2138 FillFlags(pMyDisasm, 101);
2139}
2140
2141/* =======================================
2142 * 0abh
2143 * ======================================= */
2144void __bea_callspec__ stosw_(PDISASM pMyDisasm)
2145{
2146 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2147 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2148 }
2149 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2150 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2151 }
2152 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
2153 if (GV.OperandSize == 64) {
2154 #ifndef BEA_LIGHT_DISASSEMBLY
2155 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosq ");
2156 #endif
2157 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2158 (*pMyDisasm).Argument2.ArgSize = 64;
2159 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2160 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2161 (*pMyDisasm).Argument1.ArgSize = 64;
2162 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2163 GV.EIP_++;
2164 FillFlags(pMyDisasm, 101);
2165 }
2166 else if (GV.OperandSize == 32) {
2167 #ifndef BEA_LIGHT_DISASSEMBLY
2168 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosd ");
2169 #endif
2170 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2171 (*pMyDisasm).Argument2.ArgSize = 32;
2172 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2173 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2174 (*pMyDisasm).Argument1.ArgSize = 32;
2175 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2176 GV.EIP_++;
2177 FillFlags(pMyDisasm, 101);
2178 }
2179 else {
2180 #ifndef BEA_LIGHT_DISASSEMBLY
2181 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "stosw ");
2182 #endif
2183 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
2184 (*pMyDisasm).Argument2.ArgSize = 16;
2185 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2186 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2187 (*pMyDisasm).Argument1.ArgSize = 16;
2188 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG7;
2189 GV.EIP_++;
2190 FillFlags(pMyDisasm, 101);
2191 }
2192}
2193
2194/* =======================================
2195 *
2196 * ======================================= */
2197void __bea_callspec__ syscall_(PDISASM pMyDisasm)
2198{
2199 if (GV.Architecture == 64) {
2200 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION+CONTROL_TRANSFER;
2201 #ifndef BEA_LIGHT_DISASSEMBLY
2202 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "syscall ");
2203 #endif
2204 GV.EIP_++;
2205 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1+REG11;
2206 (*pMyDisasm).Argument1.ArgSize = 64;
2207 }
2208 else {
2209 FailDecode(pMyDisasm);
2210 }
2211}
2212
2213/* =======================================
2214 *
2215 * ======================================= */
2216void __bea_callspec__ sysret_(PDISASM pMyDisasm)
2217{
2218 if (GV.Architecture == 64) {
2219 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
2220 #ifndef BEA_LIGHT_DISASSEMBLY
2221 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sysret ");
2222 #endif
2223 GV.EIP_++;
2224 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1+REG11;
2225 (*pMyDisasm).Argument2.ArgSize = 64;
2226 }
2227 else {
2228 FailDecode(pMyDisasm);
2229 }
2230}
2231
2232
2233
2234/* =======================================
2235 * 18h
2236 * ======================================= */
2237void __bea_callspec__ sbb_EbGb(PDISASM pMyDisasm)
2238{
2239 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2240 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2241 }
2242 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2243 #ifndef BEA_LIGHT_DISASSEMBLY
2244 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2245 #endif
2246 EbGb(pMyDisasm);
2247 FillFlags(pMyDisasm,93);
2248}
2249
2250/* =======================================
2251 * 19h
2252 * ======================================= */
2253void __bea_callspec__ sbb_EvGv(PDISASM pMyDisasm)
2254{
2255 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2256 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2257 }
2258 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2259 #ifndef BEA_LIGHT_DISASSEMBLY
2260 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2261 #endif
2262 EvGv(pMyDisasm);
2263 FillFlags(pMyDisasm,93);
2264}
2265
2266/* =======================================
2267 * 1ah
2268 * ======================================= */
2269void __bea_callspec__ sbb_GbEb(PDISASM pMyDisasm)
2270{
2271 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2272 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2273 }
2274 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2275 #ifndef BEA_LIGHT_DISASSEMBLY
2276 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2277 #endif
2278 GbEb(pMyDisasm);
2279 FillFlags(pMyDisasm,93);
2280}
2281
2282/* =======================================
2283 * 1bh
2284 * ======================================= */
2285void __bea_callspec__ sbb_GvEv(PDISASM pMyDisasm)
2286{
2287 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2288 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2289 }
2290 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2291 #ifndef BEA_LIGHT_DISASSEMBLY
2292 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2293 #endif
2294 GvEv(pMyDisasm);
2295 FillFlags(pMyDisasm,93);
2296}
2297
2298/* =======================================
2299 * 1ch
2300 * ======================================= */
2301void __bea_callspec__ sbb_ALIb(PDISASM pMyDisasm)
2302{
2303 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2304 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2305 }
2306 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2307 #ifndef BEA_LIGHT_DISASSEMBLY
2308 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2309 #endif
2310 ALIb(pMyDisasm);
2311 FillFlags(pMyDisasm,93);
2312}
2313
2314/* =======================================
2315 * 1dh
2316 * ======================================= */
2317void __bea_callspec__ sbb_eAX_Iv(PDISASM pMyDisasm)
2318{
2319 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2320 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2321 }
2322 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2323 #ifndef BEA_LIGHT_DISASSEMBLY
2324 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sbb ");
2325 #endif
2326 eAX_Iv(pMyDisasm);
2327 FillFlags(pMyDisasm,93);
2328}
2329
2330/* =======================================
2331 * 0f90h
2332 * ======================================= */
2333void __bea_callspec__ seto_(PDISASM pMyDisasm)
2334{
2335 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2336 #ifndef BEA_LIGHT_DISASSEMBLY
2337 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "seto ");
2338 #endif
2339 GV.MemDecoration = Arg1byte;
2340 GV.OperandSize = 8;
2341 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2342 GV.OperandSize = 32;
2343 GV.EIP_+= GV.DECALAGE_EIP+2;
2344 FillFlags(pMyDisasm,95);
2345}
2346
2347/* =======================================
2348 * 0f91h
2349 * ======================================= */
2350void __bea_callspec__ setno_(PDISASM pMyDisasm)
2351{
2352 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2353 #ifndef BEA_LIGHT_DISASSEMBLY
2354 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setno ");
2355 #endif
2356 GV.MemDecoration = Arg1byte;
2357 GV.OperandSize = 8;
2358 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2359 GV.OperandSize = 32;
2360 GV.EIP_+= GV.DECALAGE_EIP+2;
2361 FillFlags(pMyDisasm,95);
2362}
2363
2364/* =======================================
2365 * 0f90h
2366 * ======================================= */
2367void __bea_callspec__ setb_(PDISASM pMyDisasm)
2368{
2369 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2370 #ifndef BEA_LIGHT_DISASSEMBLY
2371 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setb ");
2372 #endif
2373 GV.MemDecoration = Arg1byte;
2374 GV.OperandSize = 8;
2375 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2376 GV.OperandSize = 32;
2377 GV.EIP_+= GV.DECALAGE_EIP+2;
2378 FillFlags(pMyDisasm,95);
2379}
2380
2381/* =======================================
2382 * 0f90h
2383 * ======================================= */
2384void __bea_callspec__ setnb_(PDISASM pMyDisasm)
2385{
2386 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2387 #ifndef BEA_LIGHT_DISASSEMBLY
2388 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnb ");
2389 #endif
2390 GV.MemDecoration = Arg1byte;
2391 GV.OperandSize = 8;
2392 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2393 GV.OperandSize = 32;
2394 GV.EIP_+= GV.DECALAGE_EIP+2;
2395 FillFlags(pMyDisasm,95);
2396}
2397
2398/* =======================================
2399 * 0f90h
2400 * ======================================= */
2401void __bea_callspec__ sete_(PDISASM pMyDisasm)
2402{
2403 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2404 #ifndef BEA_LIGHT_DISASSEMBLY
2405 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sete ");
2406 #endif
2407 GV.MemDecoration = Arg1byte;
2408 GV.OperandSize = 8;
2409 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2410 GV.OperandSize = 32;
2411 GV.EIP_+= GV.DECALAGE_EIP+2;
2412 FillFlags(pMyDisasm,95);
2413}
2414
2415/* =======================================
2416 * 0f90h
2417 * ======================================= */
2418void __bea_callspec__ setne_(PDISASM pMyDisasm)
2419{
2420 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2421 #ifndef BEA_LIGHT_DISASSEMBLY
2422 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setne ");
2423 #endif
2424 GV.MemDecoration = Arg1byte;
2425 GV.OperandSize = 8;
2426 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2427 GV.OperandSize = 32;
2428 GV.EIP_+= GV.DECALAGE_EIP+2;
2429 FillFlags(pMyDisasm,95);
2430}
2431
2432/* =======================================
2433 * 0f90h
2434 * ======================================= */
2435void __bea_callspec__ setbe_(PDISASM pMyDisasm)
2436{
2437 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2438 #ifndef BEA_LIGHT_DISASSEMBLY
2439 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setbe ");
2440 #endif
2441 GV.MemDecoration = Arg1byte;
2442 GV.OperandSize = 8;
2443 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2444 GV.OperandSize = 32;
2445 GV.EIP_+= GV.DECALAGE_EIP+2;
2446 FillFlags(pMyDisasm,95);
2447}
2448
2449/* =======================================
2450 * 0f90h
2451 * ======================================= */
2452void __bea_callspec__ setnbe_(PDISASM pMyDisasm)
2453{
2454 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2455 #ifndef BEA_LIGHT_DISASSEMBLY
2456 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnbe ");
2457 #endif
2458 GV.MemDecoration = Arg1byte;
2459 GV.OperandSize = 8;
2460 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2461 GV.OperandSize = 32;
2462 GV.EIP_+= GV.DECALAGE_EIP+2;
2463 FillFlags(pMyDisasm,95);
2464}
2465
2466/* =======================================
2467 * 0f90h
2468 * ======================================= */
2469void __bea_callspec__ sets_(PDISASM pMyDisasm)
2470{
2471 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2472 #ifndef BEA_LIGHT_DISASSEMBLY
2473 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sets ");
2474 #endif
2475 GV.MemDecoration = Arg1byte;
2476 GV.OperandSize = 8;
2477 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2478 GV.OperandSize = 32;
2479 GV.EIP_+= GV.DECALAGE_EIP+2;
2480 FillFlags(pMyDisasm,95);
2481}
2482
2483/* =======================================
2484 * 0f90h
2485 * ======================================= */
2486void __bea_callspec__ setns_(PDISASM pMyDisasm)
2487{
2488 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2489 #ifndef BEA_LIGHT_DISASSEMBLY
2490 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setns ");
2491 #endif
2492 GV.MemDecoration = Arg1byte;
2493 GV.OperandSize = 8;
2494 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2495 GV.OperandSize = 32;
2496 GV.EIP_+= GV.DECALAGE_EIP+2;
2497 FillFlags(pMyDisasm,95);
2498}
2499
2500/* =======================================
2501 * 0f90h
2502 * ======================================= */
2503void __bea_callspec__ setp_(PDISASM pMyDisasm)
2504{
2505 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2506 #ifndef BEA_LIGHT_DISASSEMBLY
2507 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setp ");
2508 #endif
2509 GV.MemDecoration = Arg1byte;
2510 GV.OperandSize = 8;
2511 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2512 GV.OperandSize = 32;
2513 GV.EIP_+= GV.DECALAGE_EIP+2;
2514 FillFlags(pMyDisasm,95);
2515}
2516
2517/* =======================================
2518 * 0f90h
2519 * ======================================= */
2520void __bea_callspec__ setnp_(PDISASM pMyDisasm)
2521{
2522 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2523 #ifndef BEA_LIGHT_DISASSEMBLY
2524 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnp ");
2525 #endif
2526 GV.MemDecoration = Arg1byte;
2527 GV.OperandSize = 8;
2528 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2529 GV.OperandSize = 32;
2530 GV.EIP_+= GV.DECALAGE_EIP+2;
2531 FillFlags(pMyDisasm,95);
2532}
2533
2534/* =======================================
2535 * 0f90h
2536 * ======================================= */
2537void __bea_callspec__ setge_(PDISASM pMyDisasm)
2538{
2539 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2540 #ifndef BEA_LIGHT_DISASSEMBLY
2541 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnl ");
2542 #endif
2543 GV.MemDecoration = Arg1byte;
2544 GV.OperandSize = 8;
2545 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2546 GV.OperandSize = 32;
2547 GV.EIP_+= GV.DECALAGE_EIP+2;
2548 FillFlags(pMyDisasm,95);
2549}
2550
2551/* =======================================
2552 * 0f90h
2553 * ======================================= */
2554void __bea_callspec__ setnge_(PDISASM pMyDisasm)
2555{
2556 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2557 #ifndef BEA_LIGHT_DISASSEMBLY
2558 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setl ");
2559 #endif
2560 GV.MemDecoration = Arg1byte;
2561 GV.OperandSize = 8;
2562 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2563 GV.OperandSize = 32;
2564 GV.EIP_+= GV.DECALAGE_EIP+2;
2565 FillFlags(pMyDisasm,95);
2566}
2567
2568/* =======================================
2569 * 0f90h
2570 * ======================================= */
2571void __bea_callspec__ setle_(PDISASM pMyDisasm)
2572{
2573 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2574 #ifndef BEA_LIGHT_DISASSEMBLY
2575 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setle ");
2576 #endif
2577 GV.MemDecoration = Arg1byte;
2578 GV.OperandSize = 8;
2579 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2580 GV.OperandSize = 32;
2581 GV.EIP_+= GV.DECALAGE_EIP+2;
2582 FillFlags(pMyDisasm,95);
2583}
2584
2585/* =======================================
2586 * 0f90h
2587 * ======================================= */
2588void __bea_callspec__ setnle_(PDISASM pMyDisasm)
2589{
2590 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2591 #ifndef BEA_LIGHT_DISASSEMBLY
2592 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "setnle ");
2593 #endif
2594 GV.MemDecoration = Arg1byte;
2595 GV.OperandSize = 8;
2596 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2597 GV.OperandSize = 32;
2598 GV.EIP_+= GV.DECALAGE_EIP+2;
2599 FillFlags(pMyDisasm,95);
2600}
2601
2602
2603/* =======================================
2604 * 0fa4h
2605 * ======================================= */
2606void __bea_callspec__ shld_EvGvIb(PDISASM pMyDisasm)
2607{
2608 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
2609 #ifndef BEA_LIGHT_DISASSEMBLY
2610 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shld ");
2611 #endif
2612 GV.ImmediatSize = 8;
2613 EvGv(pMyDisasm);
2614 GV.EIP_+= 1;
2615 if (!Security(0, pMyDisasm)) return;
2616 GV.third_arg = 1;
2617 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2618 #ifndef BEA_LIGHT_DISASSEMBLY
2619 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.8X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2620 #endif
2621 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2622 (*pMyDisasm).Argument3.ArgSize = 8;
2623
2624 FillFlags(pMyDisasm, 97);
2625}
2626
2627
2628/* =======================================
2629 *
2630 * ======================================= */
2631void __bea_callspec__ shld_EvGvCL(PDISASM pMyDisasm)
2632{
2633 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
2634 #ifndef BEA_LIGHT_DISASSEMBLY
2635 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shld ");
2636 #endif
2637 EvGv(pMyDisasm);
2638 GV.third_arg = 2;
2639 #ifndef BEA_LIGHT_DISASSEMBLY
2640 (void) strcpy ((*pMyDisasm).Argument3.ArgMnemonic, Registers8Bits[1]);
2641 #endif
2642 (*pMyDisasm).Argument3.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
2643 (*pMyDisasm).Argument3.ArgSize = 8;
2644 FillFlags(pMyDisasm, 97);
2645}
2646
2647/* =======================================
2648 * 0fach
2649 * ======================================= */
2650void __bea_callspec__ shrd_EvGvIb(PDISASM pMyDisasm)
2651{
2652 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
2653 #ifndef BEA_LIGHT_DISASSEMBLY
2654 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shrd ");
2655 #endif
2656 GV.ImmediatSize = 8;
2657 EvGv(pMyDisasm);
2658 GV.EIP_+= 1;
2659 if (!Security(0, pMyDisasm)) return;
2660 GV.third_arg = 1;
2661 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2662 #ifndef BEA_LIGHT_DISASSEMBLY
2663 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.8X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2664 #endif
2665 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2666 (*pMyDisasm).Argument3.ArgSize = 8;
2667
2668 FillFlags(pMyDisasm, 97);
2669}
2670
2671
2672/* =======================================
2673 *
2674 * ======================================= */
2675void __bea_callspec__ shrd_EvGvCL(PDISASM pMyDisasm)
2676{
2677 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SHIFT_ROTATE;
2678 #ifndef BEA_LIGHT_DISASSEMBLY
2679 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shrd ");
2680 #endif
2681 EvGv(pMyDisasm);
2682 GV.third_arg = 2;
2683 #ifndef BEA_LIGHT_DISASSEMBLY
2684 (void) strcpy ((*pMyDisasm).Argument3.ArgMnemonic, Registers8Bits[1]);
2685 #endif
2686 (*pMyDisasm).Argument3.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
2687 (*pMyDisasm).Argument3.ArgSize = 8;
2688 FillFlags(pMyDisasm, 97);
2689}
2690
2691
2692/* =======================================
2693 *
2694 * ======================================= */
2695void __bea_callspec__ std_(PDISASM pMyDisasm)
2696{
2697 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
2698 #ifndef BEA_LIGHT_DISASSEMBLY
2699 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "std ");
2700 #endif
2701 GV.EIP_++;
2702 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
2703 (*pMyDisasm).Argument1.ArgSize = 1;
2704 FillFlags(pMyDisasm, 99);
2705}
2706
2707
2708/* =======================================
2709 * 28h
2710 * ======================================= */
2711void __bea_callspec__ sub_EbGb(PDISASM pMyDisasm)
2712{
2713 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2714 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2715 }
2716 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2717 #ifndef BEA_LIGHT_DISASSEMBLY
2718 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2719 #endif
2720 EbGb(pMyDisasm);
2721 FillFlags(pMyDisasm,103);
2722}
2723
2724/* =======================================
2725 * 29h
2726 * ======================================= */
2727void __bea_callspec__ sub_EvGv(PDISASM pMyDisasm)
2728{
2729 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2730 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2731 }
2732 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2733 #ifndef BEA_LIGHT_DISASSEMBLY
2734 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2735 #endif
2736 EvGv(pMyDisasm);
2737 FillFlags(pMyDisasm,103);
2738}
2739
2740/* =======================================
2741 * 2ah
2742 * ======================================= */
2743void __bea_callspec__ sub_GbEb(PDISASM pMyDisasm)
2744{
2745 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2746 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2747 }
2748 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2749 #ifndef BEA_LIGHT_DISASSEMBLY
2750 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2751 #endif
2752 GbEb(pMyDisasm);
2753 FillFlags(pMyDisasm,103);
2754}
2755
2756/* =======================================
2757 * 2bh
2758 * ======================================= */
2759void __bea_callspec__ sub_GvEv(PDISASM pMyDisasm)
2760{
2761 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2762 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2763 }
2764 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2765 #ifndef BEA_LIGHT_DISASSEMBLY
2766 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2767 #endif
2768 GvEv(pMyDisasm);
2769 FillFlags(pMyDisasm,103);
2770}
2771
2772/* =======================================
2773 * 2ch
2774 * ======================================= */
2775void __bea_callspec__ sub_ALIb(PDISASM pMyDisasm)
2776{
2777 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2778 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2779 }
2780 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2781 #ifndef BEA_LIGHT_DISASSEMBLY
2782 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2783 #endif
2784 ALIb(pMyDisasm);
2785 FillFlags(pMyDisasm,103);
2786}
2787
2788/* =======================================
2789 * 2dh
2790 * ======================================= */
2791void __bea_callspec__ sub_eAX_Iv(PDISASM pMyDisasm)
2792{
2793 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2794 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2795 }
2796 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2797 #ifndef BEA_LIGHT_DISASSEMBLY
2798 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sub ");
2799 #endif
2800 eAX_Iv(pMyDisasm);
2801 FillFlags(pMyDisasm,103);
2802}
2803
2804/* =======================================
2805 * 84h
2806 * ======================================= */
2807void __bea_callspec__ test_EbGb(PDISASM pMyDisasm)
2808{
2809 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2810 #ifndef BEA_LIGHT_DISASSEMBLY
2811 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2812 #endif
2813 (*pMyDisasm).Argument1.AccessMode = READ;
2814 EbGb(pMyDisasm);
2815 FillFlags(pMyDisasm,104);
2816}
2817
2818/* =======================================
2819 * 85h
2820 * ======================================= */
2821void __bea_callspec__ test_EvGv(PDISASM pMyDisasm)
2822{
2823 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2824 #ifndef BEA_LIGHT_DISASSEMBLY
2825 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2826 #endif
2827 (*pMyDisasm).Argument1.AccessMode = READ;
2828 EvGv(pMyDisasm);
2829 FillFlags(pMyDisasm,104);
2830}
2831
2832/* =======================================
2833 * 86h
2834 * ======================================= */
2835void __bea_callspec__ test_GbEb(PDISASM pMyDisasm)
2836{
2837 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2838 #ifndef BEA_LIGHT_DISASSEMBLY
2839 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2840 #endif
2841 (*pMyDisasm).Argument1.AccessMode = READ;
2842 GbEb(pMyDisasm);
2843 FillFlags(pMyDisasm,104);
2844}
2845
2846/* =======================================
2847 * 87h
2848 * ======================================= */
2849void __bea_callspec__ test_GvEv(PDISASM pMyDisasm)
2850{
2851 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2852 #ifndef BEA_LIGHT_DISASSEMBLY
2853 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2854 #endif
2855 (*pMyDisasm).Argument1.AccessMode = READ;
2856 GvEv(pMyDisasm);
2857 FillFlags(pMyDisasm,104);
2858}
2859
2860/* =======================================
2861 * 88h
2862 * ======================================= */
2863void __bea_callspec__ test_ALIb(PDISASM pMyDisasm)
2864{
2865 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2866 #ifndef BEA_LIGHT_DISASSEMBLY
2867 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2868 #endif
2869 (*pMyDisasm).Argument1.AccessMode = READ;
2870 ALIb(pMyDisasm);
2871 FillFlags(pMyDisasm,104);
2872}
2873
2874/* =======================================
2875 * 89h
2876 * ======================================= */
2877void __bea_callspec__ test_eAX_Iv(PDISASM pMyDisasm)
2878{
2879 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
2880 #ifndef BEA_LIGHT_DISASSEMBLY
2881 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "test ");
2882 #endif
2883 (*pMyDisasm).Argument1.AccessMode = READ;
2884 eAX_Iv(pMyDisasm);
2885 FillFlags(pMyDisasm,104);
2886}
2887
2888/* =======================================
2889 *
2890 * ======================================= */
2891void __bea_callspec__ ud2_(PDISASM pMyDisasm)
2892{
2893 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
2894 #ifndef BEA_LIGHT_DISASSEMBLY
2895 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ud2 ");
2896 #endif
2897 GV.EIP_++;
2898}
2899
2900/* =======================================
2901 *
2902 * ======================================= */
2903void __bea_callspec__ vmread_(PDISASM pMyDisasm)
2904{
2905 (*pMyDisasm).Instruction.Category = VM_INSTRUCTION;
2906 #ifndef BEA_LIGHT_DISASSEMBLY
2907 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "vmread ");
2908 #endif
2909 if (GV.Architecture == 64) {
2910 GV.OperandSize = 64;
2911 }
2912 EvGv(pMyDisasm);
2913 if (GV.Architecture == 64) {
2914 GV.OperandSize = 32;
2915 }
2916}
2917
2918/* =======================================
2919 *
2920 * ======================================= */
2921void __bea_callspec__ vmwrite_(PDISASM pMyDisasm)
2922{
2923 (*pMyDisasm).Instruction.Category = VM_INSTRUCTION;
2924 #ifndef BEA_LIGHT_DISASSEMBLY
2925 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "vmwrite ");
2926 #endif
2927 if (GV.Architecture == 64) {
2928 GV.OperandSize = 64;
2929 }
2930 GvEv(pMyDisasm);
2931 if (GV.Architecture == 64) {
2932 GV.OperandSize = 32;
2933 }
2934}
2935
2936/* =======================================
2937 *
2938 * ======================================= */
2939void __bea_callspec__ wbinvd_(PDISASM pMyDisasm)
2940{
2941 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
2942 #ifndef BEA_LIGHT_DISASSEMBLY
2943 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "wbinvd ");
2944 #endif
2945 GV.EIP_++;
2946}
2947
2948/* =======================================
2949 * 9Bh
2950 * ======================================= */
2951void __bea_callspec__ wait_(PDISASM pMyDisasm)
2952{
2953 (*pMyDisasm).Instruction.Category = FPU_INSTRUCTION+FPUCONTROL;
2954 #ifndef BEA_LIGHT_DISASSEMBLY
2955 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "wait ");
2956 #endif
2957 GV.EIP_++;
2958}
2959
2960/* =======================================
2961 *
2962 * ======================================= */
2963void __bea_callspec__ wrmsr_(PDISASM pMyDisasm)
2964{
2965 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
2966 #ifndef BEA_LIGHT_DISASSEMBLY
2967 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "wrmsr ");
2968 #endif
2969 GV.EIP_++;
2970 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2;
2971 (*pMyDisasm).Argument2.ArgSize = 32;
2972}
2973
2974
2975/* =======================================
2976 * 0fc0h
2977 * ======================================= */
2978void __bea_callspec__ xadd_EbGb(PDISASM pMyDisasm)
2979{
2980 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2981 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2982 }
2983 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
2984 #ifndef BEA_LIGHT_DISASSEMBLY
2985 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xadd ");
2986 #endif
2987 EbGb(pMyDisasm);
2988 FillFlags(pMyDisasm,110);
2989}
2990
2991/* =======================================
2992 * 0fc1h
2993 * ======================================= */
2994void __bea_callspec__ xadd_EvGv(PDISASM pMyDisasm)
2995{
2996 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2997 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2998 }
2999 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3000 #ifndef BEA_LIGHT_DISASSEMBLY
3001 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xadd ");
3002 #endif
3003 EvGv(pMyDisasm);
3004 FillFlags(pMyDisasm,110);
3005}
3006
3007/* =======================================
3008 * 91h
3009 * ======================================= */
3010void __bea_callspec__ xchg_ecx(PDISASM pMyDisasm)
3011{
3012 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3013 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3014 }
3015 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3016 #ifndef BEA_LIGHT_DISASSEMBLY
3017 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3018 #endif
3019 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3020 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
3021 if (GV.OperandSize == 64) {
3022 #ifndef BEA_LIGHT_DISASSEMBLY
3023 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3024 #endif
3025 if (GV.REX.B_ == 1) {
3026 #ifndef BEA_LIGHT_DISASSEMBLY
3027 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[1+8]);
3028 #endif
3029 }
3030 else {
3031 #ifndef BEA_LIGHT_DISASSEMBLY
3032 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[1]);
3033 #endif
3034 }
3035 GV.EIP_++;
3036 (*pMyDisasm).Argument2.AccessMode = WRITE;
3037 (*pMyDisasm).Argument1.ArgSize = 64;
3038 (*pMyDisasm).Argument2.ArgSize = 64;
3039 }
3040 else if (GV.OperandSize == 32) {
3041 #ifndef BEA_LIGHT_DISASSEMBLY
3042 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3043 #endif
3044 if (GV.REX.B_ == 1) {
3045 #ifndef BEA_LIGHT_DISASSEMBLY
3046 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[1+8]);
3047 #endif
3048 }
3049 else {
3050 #ifndef BEA_LIGHT_DISASSEMBLY
3051 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[1]);
3052 #endif
3053 }
3054 GV.EIP_++;
3055 (*pMyDisasm).Argument2.AccessMode = WRITE;
3056 (*pMyDisasm).Argument1.ArgSize = 32;
3057 (*pMyDisasm).Argument2.ArgSize = 32;
3058 }
3059 else {
3060 #ifndef BEA_LIGHT_DISASSEMBLY
3061 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3062 #endif
3063 if (GV.REX.B_ == 1) {
3064 #ifndef BEA_LIGHT_DISASSEMBLY
3065 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[1+8]);
3066 #endif
3067 }
3068 else {
3069 #ifndef BEA_LIGHT_DISASSEMBLY
3070 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[1]);
3071 #endif
3072 }
3073 GV.EIP_++;
3074 (*pMyDisasm).Argument2.AccessMode = WRITE;
3075 (*pMyDisasm).Argument1.ArgSize = 16;
3076 (*pMyDisasm).Argument2.ArgSize = 16;
3077 }
3078}
3079
3080
3081/* =======================================
3082 * 92h
3083 * ======================================= */
3084void __bea_callspec__ xchg_edx(PDISASM pMyDisasm)
3085{
3086 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3087 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3088 }
3089 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3090 #ifndef BEA_LIGHT_DISASSEMBLY
3091 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3092 #endif
3093 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3094 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
3095 if (GV.OperandSize == 64) {
3096 #ifndef BEA_LIGHT_DISASSEMBLY
3097 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3098 #endif
3099 if (GV.REX.B_ == 1) {
3100 #ifndef BEA_LIGHT_DISASSEMBLY
3101 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[2+8]);
3102 #endif
3103 }
3104 else {
3105 #ifndef BEA_LIGHT_DISASSEMBLY
3106 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[2]);
3107 #endif
3108 }
3109 GV.EIP_++;
3110 (*pMyDisasm).Argument2.AccessMode = WRITE;
3111 (*pMyDisasm).Argument1.ArgSize = 64;
3112 (*pMyDisasm).Argument2.ArgSize = 64;
3113 }
3114 else if (GV.OperandSize == 32) {
3115 #ifndef BEA_LIGHT_DISASSEMBLY
3116 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3117 #endif
3118 if (GV.REX.B_ == 1) {
3119 #ifndef BEA_LIGHT_DISASSEMBLY
3120 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[2+8]);
3121 #endif
3122 }
3123 else {
3124 #ifndef BEA_LIGHT_DISASSEMBLY
3125 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[2]);
3126 #endif
3127 }
3128 GV.EIP_++;
3129 (*pMyDisasm).Argument2.AccessMode = WRITE;
3130 (*pMyDisasm).Argument1.ArgSize = 32;
3131 (*pMyDisasm).Argument2.ArgSize = 32;
3132 }
3133 else {
3134 #ifndef BEA_LIGHT_DISASSEMBLY
3135 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3136 #endif
3137 if (GV.REX.B_ == 1) {
3138 #ifndef BEA_LIGHT_DISASSEMBLY
3139 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2+8]);
3140 #endif
3141 }
3142 else {
3143 #ifndef BEA_LIGHT_DISASSEMBLY
3144 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
3145 #endif
3146 }
3147 GV.EIP_++;
3148 (*pMyDisasm).Argument2.AccessMode = WRITE;
3149 (*pMyDisasm).Argument1.ArgSize = 16;
3150 (*pMyDisasm).Argument2.ArgSize = 16;
3151 }
3152}
3153
3154
3155/* =======================================
3156 * 93h
3157 * ======================================= */
3158void __bea_callspec__ xchg_ebx(PDISASM pMyDisasm)
3159{
3160 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3161 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3162 }
3163 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3164 #ifndef BEA_LIGHT_DISASSEMBLY
3165 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3166 #endif
3167 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3168 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
3169 if (GV.OperandSize == 64) {
3170 #ifndef BEA_LIGHT_DISASSEMBLY
3171 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3172 #endif
3173 if (GV.REX.B_ == 1) {
3174 #ifndef BEA_LIGHT_DISASSEMBLY
3175 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[3+8]);
3176 #endif
3177 }
3178 else {
3179 #ifndef BEA_LIGHT_DISASSEMBLY
3180 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[3]);
3181 #endif
3182 }
3183 GV.EIP_++;
3184 (*pMyDisasm).Argument2.AccessMode = WRITE;
3185 (*pMyDisasm).Argument1.ArgSize = 64;
3186 (*pMyDisasm).Argument2.ArgSize = 64;
3187 }
3188 else if (GV.OperandSize == 32) {
3189 #ifndef BEA_LIGHT_DISASSEMBLY
3190 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3191 #endif
3192 if (GV.REX.B_ == 1) {
3193 #ifndef BEA_LIGHT_DISASSEMBLY
3194 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[3+8]);
3195 #endif
3196 }
3197 else {
3198 #ifndef BEA_LIGHT_DISASSEMBLY
3199 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[3]);
3200 #endif
3201 }
3202 GV.EIP_++;
3203 (*pMyDisasm).Argument2.AccessMode = WRITE;
3204 (*pMyDisasm).Argument1.ArgSize = 32;
3205 (*pMyDisasm).Argument2.ArgSize = 32;
3206 }
3207 else {
3208 #ifndef BEA_LIGHT_DISASSEMBLY
3209 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3210 #endif
3211 if (GV.REX.B_ == 1) {
3212 #ifndef BEA_LIGHT_DISASSEMBLY
3213 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[3+8]);
3214 #endif
3215 }
3216 else {
3217 #ifndef BEA_LIGHT_DISASSEMBLY
3218 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[3]);
3219 #endif
3220 }
3221 GV.EIP_++;
3222 (*pMyDisasm).Argument2.AccessMode = WRITE;
3223 (*pMyDisasm).Argument1.ArgSize = 16;
3224 (*pMyDisasm).Argument2.ArgSize = 16;
3225 }
3226}
3227
3228
3229/* =======================================
3230 * 94h
3231 * ======================================= */
3232void __bea_callspec__ xchg_esp(PDISASM pMyDisasm)
3233{
3234 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3235 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3236 }
3237 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3238 #ifndef BEA_LIGHT_DISASSEMBLY
3239 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3240 #endif
3241 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3242 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG4;
3243 if (GV.OperandSize == 64) {
3244 #ifndef BEA_LIGHT_DISASSEMBLY
3245 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3246 #endif
3247 if (GV.REX.B_ == 1) {
3248 #ifndef BEA_LIGHT_DISASSEMBLY
3249 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[4+8]);
3250 #endif
3251 }
3252 else {
3253 #ifndef BEA_LIGHT_DISASSEMBLY
3254 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[4]);
3255 #endif
3256 }
3257 GV.EIP_++;
3258 (*pMyDisasm).Argument2.AccessMode = WRITE;
3259 (*pMyDisasm).Argument1.ArgSize = 64;
3260 (*pMyDisasm).Argument2.ArgSize = 64;
3261 }
3262 else if (GV.OperandSize == 32) {
3263 #ifndef BEA_LIGHT_DISASSEMBLY
3264 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3265 #endif
3266 if (GV.REX.B_ == 1) {
3267 #ifndef BEA_LIGHT_DISASSEMBLY
3268 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[4+8]);
3269 #endif
3270 }
3271 else {
3272 #ifndef BEA_LIGHT_DISASSEMBLY
3273 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[4]);
3274 #endif
3275 }
3276 GV.EIP_++;
3277 (*pMyDisasm).Argument2.AccessMode = WRITE;
3278 (*pMyDisasm).Argument1.ArgSize = 32;
3279 (*pMyDisasm).Argument2.ArgSize = 32;
3280 }
3281 else {
3282 #ifndef BEA_LIGHT_DISASSEMBLY
3283 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3284 #endif
3285 if (GV.REX.B_ == 1) {
3286 #ifndef BEA_LIGHT_DISASSEMBLY
3287 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[4+8]);
3288 #endif
3289 }
3290 else {
3291 #ifndef BEA_LIGHT_DISASSEMBLY
3292 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[4]);
3293 #endif
3294 }
3295 GV.EIP_++;
3296 (*pMyDisasm).Argument2.AccessMode = WRITE;
3297 (*pMyDisasm).Argument1.ArgSize = 16;
3298 (*pMyDisasm).Argument2.ArgSize = 16;
3299 }
3300}
3301
3302
3303/* =======================================
3304 * 95h
3305 * ======================================= */
3306void __bea_callspec__ xchg_ebp(PDISASM pMyDisasm)
3307{
3308 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3309 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3310 }
3311 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3312 #ifndef BEA_LIGHT_DISASSEMBLY
3313 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3314 #endif
3315 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3316 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG5;
3317 if (GV.OperandSize == 64) {
3318 #ifndef BEA_LIGHT_DISASSEMBLY
3319 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3320 #endif
3321 if (GV.REX.B_ == 1) {
3322 #ifndef BEA_LIGHT_DISASSEMBLY
3323 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[5+8]);
3324 #endif
3325 }
3326 else {
3327 #ifndef BEA_LIGHT_DISASSEMBLY
3328 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[5]);
3329 #endif
3330 }
3331 GV.EIP_++;
3332 (*pMyDisasm).Argument2.AccessMode = WRITE;
3333 (*pMyDisasm).Argument1.ArgSize = 64;
3334 (*pMyDisasm).Argument2.ArgSize = 64;
3335 }
3336 else if (GV.OperandSize == 32) {
3337 #ifndef BEA_LIGHT_DISASSEMBLY
3338 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3339 #endif
3340 if (GV.REX.B_ == 1) {
3341 #ifndef BEA_LIGHT_DISASSEMBLY
3342 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[5+8]);
3343 #endif
3344 }
3345 else {
3346 #ifndef BEA_LIGHT_DISASSEMBLY
3347 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[5]);
3348 #endif
3349 }
3350 GV.EIP_++;
3351 (*pMyDisasm).Argument2.AccessMode = WRITE;
3352 (*pMyDisasm).Argument1.ArgSize = 32;
3353 (*pMyDisasm).Argument2.ArgSize = 32;
3354 }
3355 else {
3356 #ifndef BEA_LIGHT_DISASSEMBLY
3357 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3358 #endif
3359 if (GV.REX.B_ == 1) {
3360 #ifndef BEA_LIGHT_DISASSEMBLY
3361 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[5+8]);
3362 #endif
3363 }
3364 else {
3365 #ifndef BEA_LIGHT_DISASSEMBLY
3366 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[5]);
3367 #endif
3368 }
3369 GV.EIP_++;
3370 (*pMyDisasm).Argument2.AccessMode = WRITE;
3371 (*pMyDisasm).Argument1.ArgSize = 16;
3372 (*pMyDisasm).Argument2.ArgSize = 16;
3373 }
3374}
3375
3376
3377/* =======================================
3378 * 96h
3379 * ======================================= */
3380void __bea_callspec__ xchg_esi(PDISASM pMyDisasm)
3381{
3382 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3383 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3384 }
3385 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3386 #ifndef BEA_LIGHT_DISASSEMBLY
3387 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3388 #endif
3389 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3390 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG6;
3391 if (GV.OperandSize == 64) {
3392 #ifndef BEA_LIGHT_DISASSEMBLY
3393 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3394 #endif
3395 if (GV.REX.B_ == 1) {
3396 #ifndef BEA_LIGHT_DISASSEMBLY
3397 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[6+8]);
3398 #endif
3399 }
3400 else {
3401 #ifndef BEA_LIGHT_DISASSEMBLY
3402 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[6]);
3403 #endif
3404 }
3405 GV.EIP_++;
3406 (*pMyDisasm).Argument2.AccessMode = WRITE;
3407 (*pMyDisasm).Argument1.ArgSize = 64;
3408 (*pMyDisasm).Argument2.ArgSize = 64;
3409 }
3410 else if (GV.OperandSize == 32) {
3411 #ifndef BEA_LIGHT_DISASSEMBLY
3412 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3413 #endif
3414 if (GV.REX.B_ == 1) {
3415 #ifndef BEA_LIGHT_DISASSEMBLY
3416 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[6+8]);
3417 #endif
3418 }
3419 else {
3420 #ifndef BEA_LIGHT_DISASSEMBLY
3421 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[6]);
3422 #endif
3423 }
3424 GV.EIP_++;
3425 (*pMyDisasm).Argument2.AccessMode = WRITE;
3426 (*pMyDisasm).Argument1.ArgSize = 32;
3427 (*pMyDisasm).Argument2.ArgSize = 32;
3428 }
3429 else {
3430 #ifndef BEA_LIGHT_DISASSEMBLY
3431 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3432 #endif
3433 if (GV.REX.B_ == 1) {
3434 #ifndef BEA_LIGHT_DISASSEMBLY
3435 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[6+8]);
3436 #endif
3437 }
3438 else {
3439 #ifndef BEA_LIGHT_DISASSEMBLY
3440 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[6]);
3441 #endif
3442 }
3443 GV.EIP_++;
3444 (*pMyDisasm).Argument2.AccessMode = WRITE;
3445 (*pMyDisasm).Argument1.ArgSize = 16;
3446 (*pMyDisasm).Argument2.ArgSize = 16;
3447 }
3448}
3449
3450
3451/* =======================================
3452 * 97h
3453 * ======================================= */
3454void __bea_callspec__ xchg_edi(PDISASM pMyDisasm)
3455{
3456 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3457 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3458 }
3459 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3460 #ifndef BEA_LIGHT_DISASSEMBLY
3461 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3462 #endif
3463 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3464 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG7;
3465 if (GV.OperandSize == 64) {
3466 #ifndef BEA_LIGHT_DISASSEMBLY
3467 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
3468 #endif
3469 if (GV.REX.B_ == 1) {
3470 #ifndef BEA_LIGHT_DISASSEMBLY
3471 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[7+8]);
3472 #endif
3473 }
3474 else {
3475 #ifndef BEA_LIGHT_DISASSEMBLY
3476 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[7]);
3477 #endif
3478 }
3479 GV.EIP_++;
3480 (*pMyDisasm).Argument2.AccessMode = WRITE;
3481 (*pMyDisasm).Argument1.ArgSize = 64;
3482 (*pMyDisasm).Argument2.ArgSize = 64;
3483 }
3484 else if (GV.OperandSize == 32) {
3485 #ifndef BEA_LIGHT_DISASSEMBLY
3486 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
3487 #endif
3488 if (GV.REX.B_ == 1) {
3489 #ifndef BEA_LIGHT_DISASSEMBLY
3490 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[7+8]);
3491 #endif
3492 }
3493 else {
3494 #ifndef BEA_LIGHT_DISASSEMBLY
3495 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[7]);
3496 #endif
3497 }
3498 GV.EIP_++;
3499 (*pMyDisasm).Argument2.AccessMode = WRITE;
3500 (*pMyDisasm).Argument1.ArgSize = 32;
3501 (*pMyDisasm).Argument2.ArgSize = 32;
3502 }
3503 else {
3504 #ifndef BEA_LIGHT_DISASSEMBLY
3505 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
3506 #endif
3507 if (GV.REX.B_ == 1) {
3508 #ifndef BEA_LIGHT_DISASSEMBLY
3509 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[7+8]);
3510 #endif
3511 }
3512 else {
3513 #ifndef BEA_LIGHT_DISASSEMBLY
3514 (void) strcpy ((*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[7]);
3515 #endif
3516 }
3517 GV.EIP_++;
3518 (*pMyDisasm).Argument2.AccessMode = WRITE;
3519 (*pMyDisasm).Argument1.ArgSize = 16;
3520 (*pMyDisasm).Argument2.ArgSize = 16;
3521 }
3522}
3523
3524/* =======================================
3525 * 0d7h
3526 * ======================================= */
3527void __bea_callspec__ xlat_(PDISASM pMyDisasm)
3528{
3529 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
3530 if (GV.AddressSize == 64) {
3531 #ifndef BEA_LIGHT_DISASSEMBLY
3532 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xlatb ");
3533 #endif
3534 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3535 (*pMyDisasm).Argument1.ArgSize = 8;
3536 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
3537 (*pMyDisasm).Argument2.ArgSize = 64;
3538 GV.EIP_++;
3539 }
3540 else if (GV.AddressSize == 32) {
3541 #ifndef BEA_LIGHT_DISASSEMBLY
3542 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xlatb ");
3543 #endif
3544 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3545 (*pMyDisasm).Argument1.ArgSize = 8;
3546 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
3547 (*pMyDisasm).Argument2.ArgSize = 32;
3548 GV.EIP_++;
3549 }
3550 else {
3551 #ifndef BEA_LIGHT_DISASSEMBLY
3552 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xlatb ");
3553 #endif
3554 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
3555 (*pMyDisasm).Argument1.ArgSize = 8;
3556 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
3557 (*pMyDisasm).Argument2.ArgSize = 16;
3558 GV.EIP_++;
3559 }
3560}
3561
3562
3563/* =======================================
3564 * 30h
3565 * ======================================= */
3566void __bea_callspec__ xor_EbGb(PDISASM pMyDisasm)
3567{
3568 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3569 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3570 }
3571 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3572 #ifndef BEA_LIGHT_DISASSEMBLY
3573 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3574 #endif
3575 EbGb(pMyDisasm);
3576 FillFlags(pMyDisasm,113);
3577}
3578
3579/* =======================================
3580 * 31h
3581 * ======================================= */
3582void __bea_callspec__ xor_EvGv(PDISASM pMyDisasm)
3583{
3584 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3585 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3586 }
3587 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3588 #ifndef BEA_LIGHT_DISASSEMBLY
3589 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3590 #endif
3591 EvGv(pMyDisasm);
3592 FillFlags(pMyDisasm,113);
3593}
3594
3595/* =======================================
3596 * 32h
3597 * ======================================= */
3598void __bea_callspec__ xor_GbEb(PDISASM pMyDisasm)
3599{
3600 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3601 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3602 }
3603 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3604 #ifndef BEA_LIGHT_DISASSEMBLY
3605 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3606 #endif
3607 GbEb(pMyDisasm);
3608 FillFlags(pMyDisasm,113);
3609}
3610
3611/* =======================================
3612 * 33h
3613 * ======================================= */
3614void __bea_callspec__ xor_GvEv(PDISASM pMyDisasm)
3615{
3616 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3617 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3618 }
3619 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3620 #ifndef BEA_LIGHT_DISASSEMBLY
3621 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3622 #endif
3623 GvEv(pMyDisasm);
3624 FillFlags(pMyDisasm,113);
3625}
3626
3627/* =======================================
3628 * 34h
3629 * ======================================= */
3630void __bea_callspec__ xor_ALIb(PDISASM pMyDisasm)
3631{
3632 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3633 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3634 }
3635 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3636 #ifndef BEA_LIGHT_DISASSEMBLY
3637 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3638 #endif
3639 ALIb(pMyDisasm);
3640 FillFlags(pMyDisasm,113);
3641}
3642
3643/* =======================================
3644 * 35h
3645 * ======================================= */
3646void __bea_callspec__ xor_eAX_Iv(PDISASM pMyDisasm)
3647{
3648 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3649 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3650 }
3651 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
3652 #ifndef BEA_LIGHT_DISASSEMBLY
3653 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xor ");
3654 #endif
3655 eAX_Iv(pMyDisasm);
3656 FillFlags(pMyDisasm,113);
3657}
3658
3659
3660/* =======================================
3661 * 86h
3662 * ======================================= */
3663void __bea_callspec__ xchg_EbGb(PDISASM pMyDisasm)
3664{
3665 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3666 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3667 }
3668 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3669 #ifndef BEA_LIGHT_DISASSEMBLY
3670 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3671 #endif
3672 EbGb(pMyDisasm);
3673 FillFlags(pMyDisasm,113);
3674 (*pMyDisasm).Argument2.AccessMode = WRITE;
3675}
3676
3677/* =======================================
3678 * 87h
3679 * ======================================= */
3680void __bea_callspec__ xchg_EvGv(PDISASM pMyDisasm)
3681{
3682 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
3683 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
3684 }
3685 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
3686 #ifndef BEA_LIGHT_DISASSEMBLY
3687 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xchg ");
3688 #endif
3689 EvGv(pMyDisasm);
3690 FillFlags(pMyDisasm,113);
3691 (*pMyDisasm).Argument2.AccessMode = WRITE;
3692}
Note: See TracBrowser for help on using the repository browser.