source: Daodan/src/beaengine/Includes/instr_set/opcodes_A_M.c@ 1051

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

Daodan: TV code
File size: 250.6 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
19void __bea_callspec__ FailDecode(PDISASM pMyDisasm)
20{
21 #ifndef BEA_LIGHT_DISASSEMBLY
22 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "??? ");
23#endif
24 GV.ERROR_OPCODE = 1;
25}
26/* ====================================================================
27 *
28 * ==================================================================== */
29void __bea_callspec__ aaa_(PDISASM pMyDisasm)
30{
31 if ((*pMyDisasm).Archi == 64) {
32 FailDecode(pMyDisasm);
33 }
34 else {
35 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
36 #ifndef BEA_LIGHT_DISASSEMBLY
37 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "aaa ");
38 #endif
39 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
40 (*pMyDisasm).Argument1.ArgSize = 8;
41 GV.EIP_++;
42 };
43}
44
45/* ====================================================================
46 *
47 * ==================================================================== */
48void __bea_callspec__ aad_(PDISASM pMyDisasm)
49{
50 if ((*pMyDisasm).Archi == 64) {
51 FailDecode(pMyDisasm);
52 }
53 else {
54 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
55 #ifndef BEA_LIGHT_DISASSEMBLY
56 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "aad ");
57 #endif
58 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
59 (*pMyDisasm).Argument1.ArgSize = 16;
60 if (!Security(1, pMyDisasm)) return;
61 GV.ImmediatSize = 8;
62 if (*((UInt8*)(UIntPtr) (GV.EIP_+1)) != 0x0A) {
63 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_+1));
64 #ifndef BEA_LIGHT_DISASSEMBLY
65 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_+1)));
66 #endif
67 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
68 (*pMyDisasm).Argument2.ArgSize = 8;
69 }
70 GV.EIP_+=2;
71 };
72}
73
74/* ====================================================================
75 *
76 * ==================================================================== */
77void __bea_callspec__ aam_(PDISASM pMyDisasm)
78{
79 if ((*pMyDisasm).Archi == 64) {
80 FailDecode(pMyDisasm);
81 }
82 else {
83 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
84 #ifndef BEA_LIGHT_DISASSEMBLY
85 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "aam ");
86 #endif
87 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
88 (*pMyDisasm).Argument1.ArgSize = 16;
89 if (!Security(1, pMyDisasm)) return;
90 GV.ImmediatSize = 8;
91 if (*((UInt8*)(UIntPtr) (GV.EIP_+1)) != 0x0A) {
92 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_+1));
93 #ifndef BEA_LIGHT_DISASSEMBLY
94 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_+1)));
95 #endif
96 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
97 (*pMyDisasm).Argument2.ArgSize = 8;
98 }
99 GV.EIP_+=2;
100 };
101}
102
103/* =======================================
104 *
105 * ======================================= */
106void __bea_callspec__ aas_(PDISASM pMyDisasm)
107{
108 if ((*pMyDisasm).Archi == 64) {
109 FailDecode(pMyDisasm);
110 }
111 else {
112 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
113 #ifndef BEA_LIGHT_DISASSEMBLY
114 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "aas ");
115 #endif
116 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
117 (*pMyDisasm).Argument1.ArgSize = 8;
118 GV.EIP_++;
119 };
120}
121
122/* =======================================
123 * 00h
124 * ======================================= */
125void __bea_callspec__ add_EbGb(PDISASM pMyDisasm)
126{
127 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
128 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
129 }
130 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
131 #ifndef BEA_LIGHT_DISASSEMBLY
132 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
133 #endif
134 EbGb(pMyDisasm);
135 FillFlags(pMyDisasm,5);
136}
137
138/* =======================================
139 * 01h
140 * ======================================= */
141void __bea_callspec__ add_EvGv(PDISASM pMyDisasm)
142{
143 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
144 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
145 }
146 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
147 #ifndef BEA_LIGHT_DISASSEMBLY
148 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
149 #endif
150 EvGv(pMyDisasm);
151 FillFlags(pMyDisasm,5);
152}
153
154/* =======================================
155 * 02h
156 * ======================================= */
157void __bea_callspec__ add_GbEb(PDISASM pMyDisasm)
158{
159 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
160 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
161 }
162 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
163 #ifndef BEA_LIGHT_DISASSEMBLY
164 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
165 #endif
166 GbEb(pMyDisasm);
167 FillFlags(pMyDisasm,5);
168}
169
170/* =======================================
171 * 03h
172 * ======================================= */
173void __bea_callspec__ add_GvEv(PDISASM pMyDisasm)
174{
175 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
176 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
177 }
178 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
179 #ifndef BEA_LIGHT_DISASSEMBLY
180 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
181 #endif
182 GvEv(pMyDisasm);
183 FillFlags(pMyDisasm,5);
184}
185
186/* =======================================
187 * 04h
188 * ======================================= */
189void __bea_callspec__ add_ALIb(PDISASM pMyDisasm)
190{
191 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
192 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
193 }
194 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
195 #ifndef BEA_LIGHT_DISASSEMBLY
196 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
197 #endif
198 ALIb(pMyDisasm);
199 FillFlags(pMyDisasm,5);
200}
201
202/* =======================================
203 * 05h
204 * ======================================= */
205void __bea_callspec__ add_eAX_Iv(PDISASM pMyDisasm)
206{
207 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
208 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
209 }
210 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
211 #ifndef BEA_LIGHT_DISASSEMBLY
212 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "add ");
213 #endif
214 eAX_Iv(pMyDisasm);
215 FillFlags(pMyDisasm,5);
216}
217
218/* =======================================
219 * 10h
220 * ======================================= */
221void __bea_callspec__ adc_EbGb(PDISASM pMyDisasm)
222{
223 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
224 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
225 }
226 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
227 #ifndef BEA_LIGHT_DISASSEMBLY
228 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
229 #endif
230 EbGb(pMyDisasm);
231 FillFlags(pMyDisasm,4);
232}
233
234/* =======================================
235 * 11h
236 * ======================================= */
237void __bea_callspec__ adc_EvGv(PDISASM pMyDisasm)
238{
239 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
240 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
241 }
242 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
243 #ifndef BEA_LIGHT_DISASSEMBLY
244 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
245 #endif
246 EvGv(pMyDisasm);
247 FillFlags(pMyDisasm,4);
248}
249
250/* =======================================
251 * 12h
252 * ======================================= */
253void __bea_callspec__ adc_GbEb(PDISASM pMyDisasm)
254{
255 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
256 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
257 }
258 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
259 #ifndef BEA_LIGHT_DISASSEMBLY
260 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
261 #endif
262 GbEb(pMyDisasm);
263 FillFlags(pMyDisasm,4);
264}
265
266/* =======================================
267 * 13h
268 * ======================================= */
269void __bea_callspec__ adc_GvEv(PDISASM pMyDisasm)
270{
271 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
272 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
273 }
274 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
275 #ifndef BEA_LIGHT_DISASSEMBLY
276 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
277 #endif
278 GvEv(pMyDisasm);
279 FillFlags(pMyDisasm,4);
280}
281
282/* =======================================
283 * 14h
284 * ======================================= */
285void __bea_callspec__ adc_ALIb(PDISASM pMyDisasm)
286{
287 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
288 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
289 }
290 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
291 #ifndef BEA_LIGHT_DISASSEMBLY
292 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
293 #endif
294 ALIb(pMyDisasm);
295 FillFlags(pMyDisasm,4);
296}
297
298/* =======================================
299 * 15h
300 * ======================================= */
301void __bea_callspec__ adc_eAX_Iv(PDISASM pMyDisasm)
302{
303 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
304 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
305 }
306 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
307 #ifndef BEA_LIGHT_DISASSEMBLY
308 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "adc ");
309 #endif
310 eAX_Iv(pMyDisasm);
311 FillFlags(pMyDisasm,4);
312}
313
314/* =======================================
315 * 20h
316 * ======================================= */
317void __bea_callspec__ and_EbGb(PDISASM pMyDisasm)
318{
319 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
320 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
321 }
322 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
323 #ifndef BEA_LIGHT_DISASSEMBLY
324 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
325 #endif
326 EbGb(pMyDisasm);
327 FillFlags(pMyDisasm,6);
328}
329
330/* =======================================
331 * 21h
332 * ======================================= */
333void __bea_callspec__ and_EvGv(PDISASM pMyDisasm)
334{
335 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
336 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
337 }
338 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
339 #ifndef BEA_LIGHT_DISASSEMBLY
340 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
341 #endif
342 EvGv(pMyDisasm);
343 FillFlags(pMyDisasm,6);
344}
345
346/* =======================================
347 * 22h
348 * ======================================= */
349void __bea_callspec__ and_GbEb(PDISASM pMyDisasm)
350{
351 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
352 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
353 }
354 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
355 #ifndef BEA_LIGHT_DISASSEMBLY
356 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
357 #endif
358 GbEb(pMyDisasm);
359 FillFlags(pMyDisasm,6);
360}
361
362/* =======================================
363 * 23h
364 * ======================================= */
365void __bea_callspec__ and_GvEv(PDISASM pMyDisasm)
366{
367 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
368 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
369 }
370 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
371 #ifndef BEA_LIGHT_DISASSEMBLY
372 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
373 #endif
374 GvEv(pMyDisasm);
375 FillFlags(pMyDisasm,6);
376}
377
378/* =======================================
379 * 24h
380 * ======================================= */
381void __bea_callspec__ and_ALIb(PDISASM pMyDisasm)
382{
383 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
384 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
385 }
386 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
387 #ifndef BEA_LIGHT_DISASSEMBLY
388 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
389 #endif
390 ALIb(pMyDisasm);
391 FillFlags(pMyDisasm,6);
392}
393
394/* =======================================
395 * 25h
396 * ======================================= */
397void __bea_callspec__ and_eAX_Iv(PDISASM pMyDisasm)
398{
399 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
400 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
401 }
402 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+LOGICAL_INSTRUCTION;
403 #ifndef BEA_LIGHT_DISASSEMBLY
404 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "and ");
405 #endif
406 eAX_Iv(pMyDisasm);
407 FillFlags(pMyDisasm,6);
408}
409
410/* =======================================
411 *
412 * ======================================= */
413void __bea_callspec__ arpl_(PDISASM pMyDisasm)
414{
415
416 if (GV.Architecture == 64) {
417 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
418 #ifndef BEA_LIGHT_DISASSEMBLY
419 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsxd ");
420 #endif
421 GvEv(pMyDisasm);
422 FillFlags(pMyDisasm,69);
423 }
424 else {
425 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
426 #ifndef BEA_LIGHT_DISASSEMBLY
427 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "arpl ");
428 #endif
429 GV.OperandSize = 16;
430 EvGv(pMyDisasm);
431 GV.OperandSize = 32;
432 FillFlags(pMyDisasm,7);
433 }
434
435}
436
437/* =======================================
438 * 62h
439 * ======================================= */
440void __bea_callspec__ bound_(PDISASM pMyDisasm)
441{
442
443 if (GV.Architecture == 64) {
444 FailDecode(pMyDisasm);
445 }
446 else {
447 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
448 #ifndef BEA_LIGHT_DISASSEMBLY
449 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bound ");
450 #endif
451 GvEv(pMyDisasm);
452 GV.MemDecoration = Arg2dword;
453 (*pMyDisasm).Argument1.AccessMode = READ;
454 FillFlags(pMyDisasm,8);
455 }
456
457}
458
459/* =======================================
460 * 0fc8h
461 * ======================================= */
462void __bea_callspec__ bswap_eax(PDISASM pMyDisasm)
463{
464
465 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
466 #ifndef BEA_LIGHT_DISASSEMBLY
467 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
468 #endif
469 if (GV.OperandSize == 64) {
470 (*pMyDisasm).Argument1.ArgSize = 64;
471 if (GV.REX.B_ == 1) {
472 #ifndef BEA_LIGHT_DISASSEMBLY
473 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[8]);
474 #endif
475 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[8];
476 }
477 else {
478 #ifndef BEA_LIGHT_DISASSEMBLY
479 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
480 #endif
481 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
482 }
483 }
484 else if (GV.OperandSize == 32){
485 (*pMyDisasm).Argument1.ArgSize = 32;
486 if (GV.REX.B_ == 1) {
487 #ifndef BEA_LIGHT_DISASSEMBLY
488 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[8]);
489 #endif
490 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[8];
491 }
492 else {
493 #ifndef BEA_LIGHT_DISASSEMBLY
494 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
495 #endif
496 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
497 }
498 }
499 else {
500 (*pMyDisasm).Argument1.ArgSize = 16;
501 if (GV.REX.B_ == 1) {
502 #ifndef BEA_LIGHT_DISASSEMBLY
503 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[8]);
504 #endif
505 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[8];
506 }
507 else {
508 #ifndef BEA_LIGHT_DISASSEMBLY
509 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
510 #endif
511 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
512 }
513 }
514 GV.EIP_++;
515 FillFlags(pMyDisasm,10);
516
517}
518
519
520/* =======================================
521 * 0fc8h
522 * ======================================= */
523void __bea_callspec__ bswap_ecx(PDISASM pMyDisasm)
524{
525
526 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
527 #ifndef BEA_LIGHT_DISASSEMBLY
528 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
529 #endif
530 if (GV.OperandSize == 64) {
531 (*pMyDisasm).Argument1.ArgSize = 64;
532 if (GV.REX.B_ == 1) {
533 #ifndef BEA_LIGHT_DISASSEMBLY
534 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+8]);
535 #endif
536 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+8];
537 }
538 else {
539 #ifndef BEA_LIGHT_DISASSEMBLY
540 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+0]);
541 #endif
542 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
543 }
544 }
545 else if (GV.OperandSize == 32){
546 (*pMyDisasm).Argument1.ArgSize = 32;
547 if (GV.REX.B_ == 1) {
548 #ifndef BEA_LIGHT_DISASSEMBLY
549 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1+8]);
550 #endif
551 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+8];
552 }
553 else {
554 #ifndef BEA_LIGHT_DISASSEMBLY
555 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1+0]);
556 #endif
557 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
558 }
559 }
560 else {
561 (*pMyDisasm).Argument1.ArgSize = 16;
562 if (GV.REX.B_ == 1) {
563 #ifndef BEA_LIGHT_DISASSEMBLY
564 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1+8]);
565 #endif
566 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+8];
567 }
568 else {
569 #ifndef BEA_LIGHT_DISASSEMBLY
570 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1+0]);
571 #endif
572 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
573 }
574 }
575 GV.EIP_++;
576 FillFlags(pMyDisasm,10);
577
578}
579
580
581/* =======================================
582 * 0fc8h
583 * ======================================= */
584void __bea_callspec__ bswap_edx(PDISASM pMyDisasm)
585{
586
587 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
588 #ifndef BEA_LIGHT_DISASSEMBLY
589 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
590 #endif
591 if (GV.OperandSize == 64) {
592 (*pMyDisasm).Argument1.ArgSize = 64;
593 if (GV.REX.B_ == 1) {
594 #ifndef BEA_LIGHT_DISASSEMBLY
595 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+8]);
596 #endif
597 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+8];
598 }
599 else {
600 #ifndef BEA_LIGHT_DISASSEMBLY
601 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+0]);
602 #endif
603 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
604 }
605 }
606 else if (GV.OperandSize == 32){
607 (*pMyDisasm).Argument1.ArgSize = 32;
608 if (GV.REX.B_ == 1) {
609 #ifndef BEA_LIGHT_DISASSEMBLY
610 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2+8]);
611 #endif
612 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+8];
613 }
614 else {
615 #ifndef BEA_LIGHT_DISASSEMBLY
616 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2+0]);
617 #endif
618 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
619 }
620 }
621 else {
622 (*pMyDisasm).Argument1.ArgSize = 16;
623 if (GV.REX.B_ == 1) {
624 #ifndef BEA_LIGHT_DISASSEMBLY
625 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2+8]);
626 #endif
627 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+8];
628 }
629 else {
630 #ifndef BEA_LIGHT_DISASSEMBLY
631 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2+0]);
632 #endif
633 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
634 }
635 }
636 GV.EIP_++;
637 FillFlags(pMyDisasm,10);
638
639}
640
641
642/* =======================================
643 * 0fc8h
644 * ======================================= */
645void __bea_callspec__ bswap_ebx(PDISASM pMyDisasm)
646{
647
648 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
649 #ifndef BEA_LIGHT_DISASSEMBLY
650 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
651 #endif
652 if (GV.OperandSize == 64) {
653 (*pMyDisasm).Argument1.ArgSize = 64;
654 if (GV.REX.B_ == 1) {
655 #ifndef BEA_LIGHT_DISASSEMBLY
656 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+8]);
657 #endif
658 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+8];
659 }
660 else {
661 #ifndef BEA_LIGHT_DISASSEMBLY
662 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+0]);
663 #endif
664 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
665 }
666 }
667 else if (GV.OperandSize == 32){
668 (*pMyDisasm).Argument1.ArgSize = 32;
669 if (GV.REX.B_ == 1) {
670 #ifndef BEA_LIGHT_DISASSEMBLY
671 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3+8]);
672 #endif
673 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+8];
674 }
675 else {
676 #ifndef BEA_LIGHT_DISASSEMBLY
677 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3+0]);
678 #endif
679 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
680 }
681 }
682 else {
683 (*pMyDisasm).Argument1.ArgSize = 16;
684 if (GV.REX.B_ == 1) {
685 #ifndef BEA_LIGHT_DISASSEMBLY
686 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3+8]);
687 #endif
688 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+8];
689 }
690 else {
691 #ifndef BEA_LIGHT_DISASSEMBLY
692 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3+0]);
693 #endif
694 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
695 }
696 }
697 GV.EIP_++;
698 FillFlags(pMyDisasm,10);
699
700}
701
702
703/* =======================================
704 * 0fc8h
705 * ======================================= */
706void __bea_callspec__ bswap_esp(PDISASM pMyDisasm)
707{
708
709 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
710 #ifndef BEA_LIGHT_DISASSEMBLY
711 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
712 #endif
713 if (GV.OperandSize == 64) {
714 (*pMyDisasm).Argument1.ArgSize = 64;
715 if (GV.REX.B_ == 1) {
716 #ifndef BEA_LIGHT_DISASSEMBLY
717 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+8]);
718 #endif
719 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+8];
720 }
721 else {
722 #ifndef BEA_LIGHT_DISASSEMBLY
723 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+0]);
724 #endif
725 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
726 }
727 }
728 else if (GV.OperandSize == 32){
729 (*pMyDisasm).Argument1.ArgSize = 32;
730 if (GV.REX.B_ == 1) {
731 #ifndef BEA_LIGHT_DISASSEMBLY
732 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4+8]);
733 #endif
734 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+8];
735 }
736 else {
737 #ifndef BEA_LIGHT_DISASSEMBLY
738 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4+0]);
739 #endif
740 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
741 }
742 }
743 else {
744 (*pMyDisasm).Argument1.ArgSize = 16;
745 if (GV.REX.B_ == 1) {
746 #ifndef BEA_LIGHT_DISASSEMBLY
747 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4+8]);
748 #endif
749 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+8];
750 }
751 else {
752 #ifndef BEA_LIGHT_DISASSEMBLY
753 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4+0]);
754 #endif
755 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
756 }
757 }
758 GV.EIP_++;
759 FillFlags(pMyDisasm,10);
760
761}
762
763
764/* =======================================
765 * 0fc8h
766 * ======================================= */
767void __bea_callspec__ bswap_ebp(PDISASM pMyDisasm)
768{
769
770 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
771 #ifndef BEA_LIGHT_DISASSEMBLY
772 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
773 #endif
774 if (GV.OperandSize == 64) {
775 (*pMyDisasm).Argument1.ArgSize = 64;
776 if (GV.REX.B_ == 1) {
777 #ifndef BEA_LIGHT_DISASSEMBLY
778 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+8]);
779 #endif
780 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+8];
781 }
782 else {
783 #ifndef BEA_LIGHT_DISASSEMBLY
784 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+0]);
785 #endif
786 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
787 }
788 }
789 else if (GV.OperandSize == 32){
790 (*pMyDisasm).Argument1.ArgSize = 32;
791 if (GV.REX.B_ == 1) {
792 #ifndef BEA_LIGHT_DISASSEMBLY
793 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5+8]);
794 #endif
795 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+8];
796 }
797 else {
798 #ifndef BEA_LIGHT_DISASSEMBLY
799 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5+0]);
800 #endif
801 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
802 }
803 }
804 else {
805 (*pMyDisasm).Argument1.ArgSize = 16;
806 if (GV.REX.B_ == 1) {
807 #ifndef BEA_LIGHT_DISASSEMBLY
808 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5+8]);
809 #endif
810 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+8];
811 }
812 else {
813 #ifndef BEA_LIGHT_DISASSEMBLY
814 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5+0]);
815 #endif
816 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
817 }
818 }
819 GV.EIP_++;
820 FillFlags(pMyDisasm,10);
821
822}
823
824
825/* =======================================
826 * 0fc8h
827 * ======================================= */
828void __bea_callspec__ bswap_esi(PDISASM pMyDisasm)
829{
830
831 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
832 #ifndef BEA_LIGHT_DISASSEMBLY
833 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
834 #endif
835 if (GV.OperandSize == 64) {
836 (*pMyDisasm).Argument1.ArgSize = 64;
837 if (GV.REX.B_ == 1) {
838 #ifndef BEA_LIGHT_DISASSEMBLY
839 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+8]);
840 #endif
841 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+8];
842 }
843 else {
844 #ifndef BEA_LIGHT_DISASSEMBLY
845 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+0]);
846 #endif
847 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
848 }
849 }
850 else if (GV.OperandSize == 32){
851 (*pMyDisasm).Argument1.ArgSize = 32;
852 if (GV.REX.B_ == 1) {
853 #ifndef BEA_LIGHT_DISASSEMBLY
854 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6+8]);
855 #endif
856 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+8];
857 }
858 else {
859 #ifndef BEA_LIGHT_DISASSEMBLY
860 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6+0]);
861 #endif
862 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
863 }
864 }
865 else {
866 (*pMyDisasm).Argument1.ArgSize = 16;
867 if (GV.REX.B_ == 1) {
868 #ifndef BEA_LIGHT_DISASSEMBLY
869 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6+8]);
870 #endif
871 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+8];
872 }
873 else {
874 #ifndef BEA_LIGHT_DISASSEMBLY
875 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6+0]);
876 #endif
877 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
878 }
879 }
880 GV.EIP_++;
881 FillFlags(pMyDisasm,10);
882
883}
884
885
886/* =======================================
887 * 0fc8h
888 * ======================================= */
889void __bea_callspec__ bswap_edi(PDISASM pMyDisasm)
890{
891
892 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
893 #ifndef BEA_LIGHT_DISASSEMBLY
894 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bswap ");
895 #endif
896 if (GV.OperandSize == 64) {
897 (*pMyDisasm).Argument1.ArgSize = 64;
898 if (GV.REX.B_ == 1) {
899 #ifndef BEA_LIGHT_DISASSEMBLY
900 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+8]);
901 #endif
902 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+8];
903 }
904 else {
905 #ifndef BEA_LIGHT_DISASSEMBLY
906 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+0]);
907 #endif
908 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
909 }
910 }
911 else if (GV.OperandSize == 32){
912 (*pMyDisasm).Argument1.ArgSize = 32;
913 if (GV.REX.B_ == 1) {
914 #ifndef BEA_LIGHT_DISASSEMBLY
915 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7+8]);
916 #endif
917 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+8];
918 }
919 else {
920 #ifndef BEA_LIGHT_DISASSEMBLY
921 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7+0]);
922 #endif
923 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
924 }
925 }
926 else {
927 (*pMyDisasm).Argument1.ArgSize = 16;
928 if (GV.REX.B_ == 1) {
929 #ifndef BEA_LIGHT_DISASSEMBLY
930 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7+8]);
931 #endif
932 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+8];
933 }
934 else {
935 #ifndef BEA_LIGHT_DISASSEMBLY
936 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7+0]);
937 #endif
938 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
939 }
940 }
941 GV.EIP_++;
942 FillFlags(pMyDisasm,10);
943
944}
945
946/* =======================================
947 * 0fbch
948 * ======================================= */
949void __bea_callspec__ bsf_GvEv(PDISASM pMyDisasm)
950{
951 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
952 #ifndef BEA_LIGHT_DISASSEMBLY
953 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bsf ");
954 #endif
955 GvEv(pMyDisasm);
956 FillFlags(pMyDisasm,9);
957}
958
959/* =======================================
960 * 0fbdh
961 * ======================================= */
962void __bea_callspec__ bsr_GvEv(PDISASM pMyDisasm)
963{
964 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
965 #ifndef BEA_LIGHT_DISASSEMBLY
966 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bsr ");
967 #endif
968 GvEv(pMyDisasm);
969 FillFlags(pMyDisasm,9);
970}
971
972/* =======================================
973 * 0fbbh
974 * ======================================= */
975void __bea_callspec__ btc_EvGv(PDISASM pMyDisasm)
976{
977 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
978 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
979
980 }
981 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
982 #ifndef BEA_LIGHT_DISASSEMBLY
983 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "btc ");
984 #endif
985 EvGv(pMyDisasm);
986 (*pMyDisasm).Argument1.AccessMode = READ;
987 FillFlags(pMyDisasm,11);
988}
989
990/* =======================================
991 * 0fa3h
992 * ======================================= */
993void __bea_callspec__ bt_EvGv(PDISASM pMyDisasm)
994{
995 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
996 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
997 }
998 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
999 #ifndef BEA_LIGHT_DISASSEMBLY
1000 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bt ");
1001 #endif
1002 EvGv(pMyDisasm);
1003 (*pMyDisasm).Argument1.AccessMode = READ;
1004 FillFlags(pMyDisasm,11);
1005}
1006
1007/* =======================================
1008 * 0fb3h
1009 * ======================================= */
1010void __bea_callspec__ btr_EvGv(PDISASM pMyDisasm)
1011{
1012 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1013 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1014 }
1015 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
1016 #ifndef BEA_LIGHT_DISASSEMBLY
1017 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "btr ");
1018 #endif
1019 EvGv(pMyDisasm);
1020 (*pMyDisasm).Argument1.AccessMode = READ;
1021 FillFlags(pMyDisasm,11);
1022}
1023
1024/* =======================================
1025 * 0fabh
1026 * ======================================= */
1027void __bea_callspec__ bts_EvGv(PDISASM pMyDisasm)
1028{
1029 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1030 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1031 }
1032 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+BIT_UInt8;
1033 #ifndef BEA_LIGHT_DISASSEMBLY
1034 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "bts ");
1035 #endif
1036 EvGv(pMyDisasm);
1037 (*pMyDisasm).Argument1.AccessMode = READ;
1038 FillFlags(pMyDisasm,11);
1039}
1040
1041/* =======================================
1042 * e8h
1043 * ======================================= */
1044void __bea_callspec__ call_(PDISASM pMyDisasm)
1045{
1046 UInt64 MyAddress;
1047 long MyNumber;
1048 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1049 (*pMyDisasm).Instruction.BranchType = CallType;
1050 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
1051 (*pMyDisasm).Argument1.AccessMode = READ;
1052 #ifndef BEA_LIGHT_DISASSEMBLY
1053 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "call ");
1054 #endif
1055 if (GV.OperandSize >= 32) {
1056 if (!Security(5, pMyDisasm)) return;
1057 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1))+5+GV.NB_PREFIX;
1058 CalculateRelativeAddress(&MyAddress,(Int64) MyNumber, pMyDisasm);
1059 (*pMyDisasm).Instruction.AddrValue = MyAddress;
1060 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1061 if (MyAddress >= 0x80000000) {
1062 #ifndef BEA_LIGHT_DISASSEMBLY
1063 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
1064 #endif
1065 }
1066 else {
1067 #ifndef BEA_LIGHT_DISASSEMBLY
1068 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
1069 #endif
1070 }
1071 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
1072 (*pMyDisasm).Instruction.AddrValue = MyAddress;
1073 GV.EIP_+=5;
1074 }
1075 else {
1076 if (!Security(3, pMyDisasm)) return;
1077 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1))+3+GV.NB_PREFIX;
1078 CalculateRelativeAddress(&MyAddress,(Int64) MyNumber, pMyDisasm);
1079 MyAddress = MyAddress & 0xffff;
1080 (*pMyDisasm).Instruction.AddrValue = MyAddress;
1081 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1082 #ifndef BEA_LIGHT_DISASSEMBLY
1083 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
1084 #endif
1085 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
1086 (*pMyDisasm).Instruction.AddrValue = MyAddress;
1087 GV.EIP_+=3;
1088 }
1089}
1090
1091/* =======================================
1092 *
1093 * ======================================= */
1094void __bea_callspec__ callf_(PDISASM pMyDisasm)
1095{
1096 UInt32 MyNumber;
1097 UInt64 MyAddress;
1098 size_t i = 0;
1099 if (GV.Architecture == 64) {
1100 FailDecode(pMyDisasm);
1101 }
1102 else {
1103 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
1104 (*pMyDisasm).Instruction.BranchType = CallType;
1105 if (GV.SYNTAX_ == ATSyntax) {
1106 #ifndef BEA_LIGHT_DISASSEMBLY
1107 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lcall ");
1108 #endif
1109 #ifndef BEA_LIGHT_DISASSEMBLY
1110 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic,"\x24");
1111 #endif
1112 i++;
1113 }
1114 else {
1115 #ifndef BEA_LIGHT_DISASSEMBLY
1116 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "call far ");
1117 #endif
1118 }
1119 if (GV.OperandSize ==32) {
1120 if (!Security(7, pMyDisasm)) return;
1121 MyNumber = *((UInt16*)(UIntPtr) (GV.EIP_+5));
1122 #ifndef BEA_LIGHT_DISASSEMBLY
1123 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.4X",(Int64) MyNumber);
1124 #endif
1125 }
1126 else {
1127 if (!Security(5, pMyDisasm)) return;
1128 MyNumber = *((UInt16*)(UIntPtr) (GV.EIP_+3));
1129 #ifndef BEA_LIGHT_DISASSEMBLY
1130 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.4X",(Int64) MyNumber);
1131 #endif
1132 }
1133 if (GV.SYNTAX_ == ATSyntax) {
1134 #ifndef BEA_LIGHT_DISASSEMBLY
1135 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic+i, " , \x24");
1136 #endif
1137 i+=4;
1138 }
1139 else {
1140 #ifndef BEA_LIGHT_DISASSEMBLY
1141 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic+i, " : ");
1142 #endif
1143 i+=3;
1144 }
1145 MyAddress = MyNumber*16;
1146 MyNumber = *((UInt32*)(UIntPtr) (GV.EIP_+1));
1147 if (GV.OperandSize == 16) {
1148 MyNumber = MyNumber & 0xffff;
1149 }
1150 #ifndef BEA_LIGHT_DISASSEMBLY
1151 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.8X",(Int64) MyNumber);
1152 #endif
1153 if (GV.OperandSize == 32) {
1154 GV.EIP_+=7;
1155 }
1156 else {
1157 GV.EIP_+=5;
1158 }
1159 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1160 (*pMyDisasm).Argument1.AccessMode = READ;
1161 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG4;
1162 (*pMyDisasm).Instruction.AddrValue = MyAddress + MyNumber;
1163 }
1164}
1165
1166/* =======================================
1167 * 99h
1168 * ======================================= */
1169void __bea_callspec__ cdq_(PDISASM pMyDisasm)
1170{
1171 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1172 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG2;
1173 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
1174 if (GV.OperandSize == 64) {
1175 if (GV.SYNTAX_ == ATSyntax) {
1176 #ifndef BEA_LIGHT_DISASSEMBLY
1177 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cqto ");
1178 #endif
1179 }
1180 else {
1181 #ifndef BEA_LIGHT_DISASSEMBLY
1182 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cqo ");
1183 #endif
1184 }
1185 (*pMyDisasm).Argument1.ArgSize = 64;
1186 }
1187 else if (GV.OperandSize ==32) {
1188 if (GV.SYNTAX_ == ATSyntax) {
1189 #ifndef BEA_LIGHT_DISASSEMBLY
1190 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cltd ");
1191 #endif
1192 }
1193 else {
1194 #ifndef BEA_LIGHT_DISASSEMBLY
1195 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cdq ");
1196 #endif
1197 }
1198 (*pMyDisasm).Argument1.ArgSize = 32;
1199 }
1200 else {
1201 if (GV.SYNTAX_ == ATSyntax) {
1202 #ifndef BEA_LIGHT_DISASSEMBLY
1203 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwtd ");
1204 #endif
1205 }
1206 else {
1207 #ifndef BEA_LIGHT_DISASSEMBLY
1208 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwd ");
1209 #endif
1210 }
1211 (*pMyDisasm).Argument1.ArgSize = 16;
1212 }
1213 GV.EIP_++;
1214}
1215
1216/* =======================================
1217 *
1218 * ======================================= */
1219void __bea_callspec__ clts_(PDISASM pMyDisasm)
1220{
1221 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
1222 #ifndef BEA_LIGHT_DISASSEMBLY
1223 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "clts ");
1224 #endif
1225 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+CR_REG+REG0;
1226 (*pMyDisasm).Argument1.ArgSize = 1;
1227 FillFlags(pMyDisasm, 17);
1228 GV.EIP_++;
1229}
1230
1231
1232/* =======================================
1233 * F5h
1234 * ======================================= */
1235void __bea_callspec__ cmc_(PDISASM pMyDisasm)
1236{
1237 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1238 #ifndef BEA_LIGHT_DISASSEMBLY
1239 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmc ");
1240 #endif
1241 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1242 (*pMyDisasm).Argument1.ArgSize = 1;
1243 FillFlags(pMyDisasm, 18);
1244 GV.EIP_++;
1245}
1246
1247/* =======================================
1248 *
1249 * ======================================= */
1250void __bea_callspec__ cmovo_(PDISASM pMyDisasm)
1251{
1252 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1253 #ifndef BEA_LIGHT_DISASSEMBLY
1254 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovo ");
1255 #endif
1256 GvEv(pMyDisasm);
1257 FillFlags(pMyDisasm, 19);
1258}
1259
1260/* =======================================
1261 *
1262 * ======================================= */
1263void __bea_callspec__ cmovno_(PDISASM pMyDisasm)
1264{
1265 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1266 #ifndef BEA_LIGHT_DISASSEMBLY
1267 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovno ");
1268 #endif
1269 GvEv(pMyDisasm);
1270 FillFlags(pMyDisasm, 19);
1271}
1272
1273/* =======================================
1274 *
1275 * ======================================= */
1276void __bea_callspec__ cmovb_(PDISASM pMyDisasm)
1277{
1278 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1279 #ifndef BEA_LIGHT_DISASSEMBLY
1280 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovb ");
1281 #endif
1282 GvEv(pMyDisasm);
1283 FillFlags(pMyDisasm, 19);
1284}
1285
1286/* =======================================
1287 *
1288 * ======================================= */
1289void __bea_callspec__ cmovnb_(PDISASM pMyDisasm)
1290{
1291 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1292 #ifndef BEA_LIGHT_DISASSEMBLY
1293 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnb ");
1294 #endif
1295 GvEv(pMyDisasm);
1296 FillFlags(pMyDisasm, 19);
1297}
1298
1299/* =======================================
1300 *
1301 * ======================================= */
1302void __bea_callspec__ cmove_(PDISASM pMyDisasm)
1303{
1304 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1305 #ifndef BEA_LIGHT_DISASSEMBLY
1306 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmove ");
1307 #endif
1308 GvEv(pMyDisasm);
1309 FillFlags(pMyDisasm, 19);
1310}
1311
1312/* =======================================
1313 *
1314 * ======================================= */
1315void __bea_callspec__ cmovne_(PDISASM pMyDisasm)
1316{
1317 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1318 #ifndef BEA_LIGHT_DISASSEMBLY
1319 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovne ");
1320 #endif
1321 GvEv(pMyDisasm);
1322 FillFlags(pMyDisasm, 19);
1323}
1324
1325/* =======================================
1326 *
1327 * ======================================= */
1328void __bea_callspec__ cmovbe_(PDISASM pMyDisasm)
1329{
1330 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1331 #ifndef BEA_LIGHT_DISASSEMBLY
1332 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovbe ");
1333 #endif
1334 GvEv(pMyDisasm);
1335 FillFlags(pMyDisasm, 19);
1336}
1337
1338/* =======================================
1339 *
1340 * ======================================= */
1341void __bea_callspec__ cmovnbe_(PDISASM pMyDisasm)
1342{
1343 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1344 #ifndef BEA_LIGHT_DISASSEMBLY
1345 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnbe ");
1346 #endif
1347 GvEv(pMyDisasm);
1348 FillFlags(pMyDisasm, 19);
1349}
1350
1351/* =======================================
1352 *
1353 * ======================================= */
1354void __bea_callspec__ cmovs_(PDISASM pMyDisasm)
1355{
1356 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1357 #ifndef BEA_LIGHT_DISASSEMBLY
1358 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovs ");
1359 #endif
1360 GvEv(pMyDisasm);
1361 FillFlags(pMyDisasm, 19);
1362}
1363
1364/* =======================================
1365 *
1366 * ======================================= */
1367void __bea_callspec__ cmovns_(PDISASM pMyDisasm)
1368{
1369 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1370 #ifndef BEA_LIGHT_DISASSEMBLY
1371 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovns ");
1372 #endif
1373 GvEv(pMyDisasm);
1374 FillFlags(pMyDisasm, 19);
1375}
1376
1377/* =======================================
1378 *
1379 * ======================================= */
1380void __bea_callspec__ cmovp_(PDISASM pMyDisasm)
1381{
1382 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1383 #ifndef BEA_LIGHT_DISASSEMBLY
1384 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovp ");
1385 #endif
1386 GvEv(pMyDisasm);
1387 FillFlags(pMyDisasm, 19);
1388}
1389
1390/* =======================================
1391 *
1392 * ======================================= */
1393void __bea_callspec__ cmovnp_(PDISASM pMyDisasm)
1394{
1395 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1396 #ifndef BEA_LIGHT_DISASSEMBLY
1397 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnp ");
1398 #endif
1399 GvEv(pMyDisasm);
1400 FillFlags(pMyDisasm, 19);
1401}
1402
1403/* =======================================
1404 *
1405 * ======================================= */
1406void __bea_callspec__ cmovl_(PDISASM pMyDisasm)
1407{
1408 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1409 #ifndef BEA_LIGHT_DISASSEMBLY
1410 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovl ");
1411 #endif
1412 GvEv(pMyDisasm);
1413 FillFlags(pMyDisasm, 19);
1414}
1415
1416/* =======================================
1417 *
1418 * ======================================= */
1419void __bea_callspec__ cmovnl_(PDISASM pMyDisasm)
1420{
1421 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1422 #ifndef BEA_LIGHT_DISASSEMBLY
1423 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnl ");
1424 #endif
1425 GvEv(pMyDisasm);
1426 FillFlags(pMyDisasm, 19);
1427}
1428
1429/* =======================================
1430 *
1431 * ======================================= */
1432void __bea_callspec__ cmovle_(PDISASM pMyDisasm)
1433{
1434 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1435 #ifndef BEA_LIGHT_DISASSEMBLY
1436 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovle ");
1437 #endif
1438 GvEv(pMyDisasm);
1439 FillFlags(pMyDisasm, 19);
1440}
1441
1442/* =======================================
1443 *
1444 * ======================================= */
1445void __bea_callspec__ cmovnle_(PDISASM pMyDisasm)
1446{
1447 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1448 #ifndef BEA_LIGHT_DISASSEMBLY
1449 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmovnle ");
1450 #endif
1451 GvEv(pMyDisasm);
1452 FillFlags(pMyDisasm, 19);
1453}
1454
1455/* =======================================
1456 *
1457 * ======================================= */
1458void __bea_callspec__ cmpx_EbGb(PDISASM pMyDisasm)
1459{
1460 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1461 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1462 }
1463 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1464 #ifndef BEA_LIGHT_DISASSEMBLY
1465 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpxchg ");
1466 #endif
1467 EbGb(pMyDisasm);
1468 FillFlags(pMyDisasm,22);
1469}
1470
1471/* =======================================
1472 *
1473 * ======================================= */
1474void __bea_callspec__ cmpx_EvGv(PDISASM pMyDisasm)
1475{
1476 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1477 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1478 }
1479 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1480 #ifndef BEA_LIGHT_DISASSEMBLY
1481 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpxchg ");
1482 #endif
1483 EvGv(pMyDisasm);
1484 FillFlags(pMyDisasm,22);
1485}
1486
1487/* =======================================
1488 * 38h
1489 * ======================================= */
1490void __bea_callspec__ cmp_EbGb(PDISASM pMyDisasm)
1491{
1492 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1493 #ifndef BEA_LIGHT_DISASSEMBLY
1494 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1495 #endif
1496 EbGb(pMyDisasm);
1497 (*pMyDisasm).Argument1.AccessMode = READ;
1498 FillFlags(pMyDisasm,20);
1499}
1500
1501/* =======================================
1502 * 39h
1503 * ======================================= */
1504void __bea_callspec__ cmp_EvGv(PDISASM pMyDisasm)
1505{
1506 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1507 #ifndef BEA_LIGHT_DISASSEMBLY
1508 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1509 #endif
1510 EvGv(pMyDisasm);
1511 (*pMyDisasm).Argument1.AccessMode = READ;
1512 FillFlags(pMyDisasm,20);
1513}
1514
1515/* =======================================
1516 * 3ah
1517 * ======================================= */
1518void __bea_callspec__ cmp_GbEb(PDISASM pMyDisasm)
1519{
1520 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1521 #ifndef BEA_LIGHT_DISASSEMBLY
1522 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1523 #endif
1524 GbEb(pMyDisasm);
1525 (*pMyDisasm).Argument1.AccessMode = READ;
1526 FillFlags(pMyDisasm,20);
1527}
1528
1529/* =======================================
1530 * 3bh
1531 * ======================================= */
1532void __bea_callspec__ cmp_GvEv(PDISASM pMyDisasm)
1533{
1534 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1535 #ifndef BEA_LIGHT_DISASSEMBLY
1536 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1537 #endif
1538 GvEv(pMyDisasm);
1539 (*pMyDisasm).Argument1.AccessMode = READ;
1540 FillFlags(pMyDisasm,20);
1541}
1542
1543/* =======================================
1544 * 3ch
1545 * ======================================= */
1546void __bea_callspec__ cmp_ALIb(PDISASM pMyDisasm)
1547{
1548 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1549 #ifndef BEA_LIGHT_DISASSEMBLY
1550 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1551 #endif
1552 ALIb(pMyDisasm);
1553 (*pMyDisasm).Argument1.AccessMode = READ;
1554 FillFlags(pMyDisasm,20);
1555}
1556
1557/* =======================================
1558 * 3dh
1559 * ======================================= */
1560void __bea_callspec__ cmp_eAX_Iv(PDISASM pMyDisasm)
1561{
1562 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1563 #ifndef BEA_LIGHT_DISASSEMBLY
1564 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmp ");
1565 #endif
1566 eAX_Iv(pMyDisasm);
1567 (*pMyDisasm).Argument1.AccessMode = READ;
1568 FillFlags(pMyDisasm,20);
1569}
1570
1571/* =======================================
1572 * a6h
1573 * ======================================= */
1574void __bea_callspec__ cmpsb_(PDISASM pMyDisasm)
1575{
1576
1577 /* ========= 0xf3 */
1578 if (GV.PrefRepe == 1) {
1579 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
1580 }
1581 /* ========= 0xf2 */
1582 if (GV.PrefRepne == 1) {
1583 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
1584 }
1585 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
1586 #ifndef BEA_LIGHT_DISASSEMBLY
1587 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsb ");
1588 #endif
1589 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1590 (*pMyDisasm).Argument1.ArgSize = 8;
1591 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
1592 (*pMyDisasm).Argument1.AccessMode = READ;
1593 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1594 (*pMyDisasm).Argument2.ArgSize = 8;
1595 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
1596 FillFlags(pMyDisasm,21);
1597 GV.EIP_++;
1598}
1599
1600/* =======================================
1601 * a7h
1602 * ======================================= */
1603void __bea_callspec__ cmps_(PDISASM pMyDisasm)
1604{
1605 /* ========= 0xf3 */
1606 if (GV.PrefRepe == 1) {
1607 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
1608 }
1609 /* ========= 0xf2 */
1610 if (GV.PrefRepne == 1) {
1611 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
1612 }
1613 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
1614 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
1615 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
1616 (*pMyDisasm).Argument1.AccessMode = READ;
1617 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
1618 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
1619 if (GV.Architecture == 64) {
1620 #ifndef BEA_LIGHT_DISASSEMBLY
1621 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsq ");
1622 #endif
1623 (*pMyDisasm).Argument1.ArgSize = 64;
1624 (*pMyDisasm).Argument2.ArgSize = 64;
1625 }
1626 else if (GV.OperandSize == 32) {
1627 #ifndef BEA_LIGHT_DISASSEMBLY
1628 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsd ");
1629 #endif
1630 (*pMyDisasm).Argument1.ArgSize = 32;
1631 (*pMyDisasm).Argument2.ArgSize = 32;
1632 }
1633 else {
1634 #ifndef BEA_LIGHT_DISASSEMBLY
1635 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsw ");
1636 #endif
1637 (*pMyDisasm).Argument1.ArgSize = 16;
1638 (*pMyDisasm).Argument2.ArgSize = 16;
1639 }
1640 FillFlags(pMyDisasm,21);
1641 GV.EIP_++;
1642}
1643
1644/* =======================================
1645 * 98h
1646 * ======================================= */
1647void __bea_callspec__ cwde_(PDISASM pMyDisasm)
1648{
1649 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
1650 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
1651 if (GV.OperandSize == 64) {
1652 if (GV.SYNTAX_ == ATSyntax) {
1653 #ifndef BEA_LIGHT_DISASSEMBLY
1654 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cltq ");
1655 #endif
1656 }
1657 else {
1658 #ifndef BEA_LIGHT_DISASSEMBLY
1659 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cdqe ");
1660 #endif
1661 }
1662 (*pMyDisasm).Argument1.ArgSize = 64;
1663 }
1664 else if (GV.OperandSize == 32) {
1665 if (GV.SYNTAX_ == ATSyntax) {
1666 #ifndef BEA_LIGHT_DISASSEMBLY
1667 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwtl ");
1668 #endif
1669 }
1670 else {
1671 #ifndef BEA_LIGHT_DISASSEMBLY
1672 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cwde ");
1673 #endif
1674 }
1675 (*pMyDisasm).Argument1.ArgSize = 32;
1676 }
1677 else {
1678 if (GV.SYNTAX_ == ATSyntax) {
1679 #ifndef BEA_LIGHT_DISASSEMBLY
1680 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cbtw ");
1681 #endif
1682 }
1683 else {
1684 #ifndef BEA_LIGHT_DISASSEMBLY
1685 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cbw ");
1686 #endif
1687 }
1688 (*pMyDisasm).Argument1.ArgSize = 16;
1689 }
1690 GV.EIP_++;
1691}
1692
1693/* =======================================
1694 * f8h
1695 * ======================================= */
1696void __bea_callspec__ clc_(PDISASM pMyDisasm)
1697{
1698 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1699 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1700 #ifndef BEA_LIGHT_DISASSEMBLY
1701 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "clc ");
1702 #endif
1703 (*pMyDisasm).Argument1.ArgSize = 1;
1704 FillFlags(pMyDisasm, 14);
1705 GV.EIP_++;
1706}
1707
1708/* =======================================
1709 * f8h
1710 * ======================================= */
1711void __bea_callspec__ cld_(PDISASM pMyDisasm)
1712{
1713 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1714 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1715 #ifndef BEA_LIGHT_DISASSEMBLY
1716 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cld ");
1717 #endif
1718 (*pMyDisasm).Argument1.ArgSize = 1;
1719 FillFlags(pMyDisasm, 15);
1720 GV.EIP_++;
1721}
1722
1723/* =======================================
1724 *
1725 * ======================================= */
1726void __bea_callspec__ cli_(PDISASM pMyDisasm)
1727{
1728 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
1729 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
1730 #ifndef BEA_LIGHT_DISASSEMBLY
1731 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cli ");
1732 #endif
1733 (*pMyDisasm).Argument1.ArgSize = 1;
1734 FillFlags(pMyDisasm, 16);
1735 GV.EIP_++;
1736}
1737
1738/* =======================================
1739 * 0fa2h
1740 * ======================================= */
1741void __bea_callspec__ cpuid_(PDISASM pMyDisasm)
1742{
1743 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
1744 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0+REG1+REG2+REG3;
1745 #ifndef BEA_LIGHT_DISASSEMBLY
1746 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cpuid ");
1747 #endif
1748 (*pMyDisasm).Argument1.ArgSize = 32;
1749 GV.EIP_++;
1750}
1751
1752/* =======================================
1753 *
1754 * ======================================= */
1755void __bea_callspec__ daa_(PDISASM pMyDisasm)
1756{
1757
1758 if (GV.Architecture == 64) {
1759 FailDecode(pMyDisasm);
1760 }
1761 else {
1762 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1763 #ifndef BEA_LIGHT_DISASSEMBLY
1764 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "daa ");
1765 #endif
1766 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
1767 (*pMyDisasm).Argument1.ArgSize = 8;
1768 FillFlags(pMyDisasm,28);
1769 GV.EIP_++;
1770 }
1771
1772}
1773
1774/* =======================================
1775 *
1776 * ======================================= */
1777void __bea_callspec__ das_(PDISASM pMyDisasm)
1778{
1779
1780 if (GV.Architecture == 64) {
1781 FailDecode(pMyDisasm);
1782 }
1783 else {
1784 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1785 #ifndef BEA_LIGHT_DISASSEMBLY
1786 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "das ");
1787 #endif
1788 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
1789 (*pMyDisasm).Argument1.ArgSize = 8;
1790 FillFlags(pMyDisasm,29);
1791 GV.EIP_++;
1792 }
1793
1794}
1795
1796/* =======================================
1797 * 48h
1798 * ======================================= */
1799void __bea_callspec__ dec_eax(PDISASM pMyDisasm)
1800{
1801 if (GV.Architecture == 64) {
1802 if (!Security(0, pMyDisasm)) return;
1803 GV.REX.W_ = 1;
1804 GV.REX.R_ = 0;
1805 GV.REX.X_ = 0;
1806 GV.REX.B_ = 0;
1807 GV.REX.state = InUsePrefix;
1808 GV.EIP_++;
1809 GV.NB_PREFIX++;
1810 (*pMyDisasm).Prefix.Number++;
1811 GV.OperandSize = 64;
1812 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
1813 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
1814 GV.OperandSize = 32;
1815
1816 }
1817 else {
1818 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1819 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1820 }
1821 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1822 #ifndef BEA_LIGHT_DISASSEMBLY
1823 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
1824 #endif
1825 if (GV.OperandSize == 32) {
1826 #ifndef BEA_LIGHT_DISASSEMBLY
1827 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
1828 #endif
1829 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
1830 (*pMyDisasm).Argument1.ArgSize = 32;
1831 }
1832 else {
1833 #ifndef BEA_LIGHT_DISASSEMBLY
1834 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
1835 #endif
1836 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
1837 (*pMyDisasm).Argument1.ArgSize = 16;
1838 }
1839 GV.EIP_++;
1840 FillFlags(pMyDisasm, 30);
1841 }
1842}
1843
1844/* =======================================
1845 * 49h
1846 * ======================================= */
1847void __bea_callspec__ dec_ecx(PDISASM pMyDisasm)
1848{
1849 if (GV.Architecture == 64) {
1850 if (!Security(0, pMyDisasm)) return;
1851 GV.REX.W_ = 1;
1852 GV.REX.R_ = 0;
1853 GV.REX.X_ = 0;
1854 GV.REX.B_ = 1;
1855 GV.REX.state = InUsePrefix;
1856 GV.EIP_++;
1857 GV.NB_PREFIX++;
1858 (*pMyDisasm).Prefix.Number++;
1859 GV.OperandSize = 64;
1860 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
1861 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
1862 GV.OperandSize = 32;
1863
1864 }
1865 else {
1866 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1867 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1868 }
1869 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1870 #ifndef BEA_LIGHT_DISASSEMBLY
1871 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
1872 #endif
1873 if (GV.OperandSize == 32) {
1874 #ifndef BEA_LIGHT_DISASSEMBLY
1875 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1]);
1876 #endif
1877 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
1878 (*pMyDisasm).Argument1.ArgSize = 32;
1879 }
1880 else {
1881 #ifndef BEA_LIGHT_DISASSEMBLY
1882 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1]);
1883 #endif
1884 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
1885 (*pMyDisasm).Argument1.ArgSize = 16;
1886 }
1887 GV.EIP_++;
1888 FillFlags(pMyDisasm, 30);
1889 }
1890}
1891
1892/* =======================================
1893 * 4ah
1894 * ======================================= */
1895void __bea_callspec__ dec_edx(PDISASM pMyDisasm)
1896{
1897 if (GV.Architecture == 64) {
1898 if (!Security(0, pMyDisasm)) return;
1899 GV.REX.W_ = 1;
1900 GV.REX.R_ = 0;
1901 GV.REX.X_ = 1;
1902 GV.REX.B_ = 0;
1903 GV.REX.state = InUsePrefix;
1904 GV.EIP_++;
1905 GV.NB_PREFIX++;
1906 (*pMyDisasm).Prefix.Number++;
1907 GV.OperandSize = 64;
1908 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
1909 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
1910 GV.OperandSize = 32;
1911
1912 }
1913 else {
1914 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1915 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1916 }
1917 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1918 #ifndef BEA_LIGHT_DISASSEMBLY
1919 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
1920 #endif
1921 if (GV.OperandSize == 32) {
1922 #ifndef BEA_LIGHT_DISASSEMBLY
1923 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2]);
1924 #endif
1925 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
1926 (*pMyDisasm).Argument1.ArgSize = 32;
1927 }
1928 else {
1929 #ifndef BEA_LIGHT_DISASSEMBLY
1930 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
1931 #endif
1932 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
1933 (*pMyDisasm).Argument1.ArgSize = 16;
1934 }
1935 GV.EIP_++;
1936 FillFlags(pMyDisasm, 30);
1937 }
1938}
1939
1940/* =======================================
1941 * 4bh
1942 * ======================================= */
1943void __bea_callspec__ dec_ebx(PDISASM pMyDisasm)
1944{
1945 if (GV.Architecture == 64) {
1946 if (!Security(0, pMyDisasm)) return;
1947 GV.REX.W_ = 1;
1948 GV.REX.R_ = 0;
1949 GV.REX.X_ = 1;
1950 GV.REX.B_ = 1;
1951 GV.REX.state = InUsePrefix;
1952 GV.EIP_++;
1953 GV.NB_PREFIX++;
1954 (*pMyDisasm).Prefix.Number++;
1955 GV.OperandSize = 64;
1956 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
1957 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
1958 GV.OperandSize = 32;
1959
1960 }
1961 else {
1962 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
1963 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
1964 }
1965 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1966 #ifndef BEA_LIGHT_DISASSEMBLY
1967 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
1968 #endif
1969 if (GV.OperandSize == 32) {
1970 #ifndef BEA_LIGHT_DISASSEMBLY
1971 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3]);
1972 #endif
1973 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
1974 (*pMyDisasm).Argument1.ArgSize = 32;
1975 }
1976 else {
1977 #ifndef BEA_LIGHT_DISASSEMBLY
1978 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3]);
1979 #endif
1980 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
1981 (*pMyDisasm).Argument1.ArgSize = 16;
1982 }
1983 GV.EIP_++;
1984 FillFlags(pMyDisasm, 30);
1985 }
1986}
1987
1988/* =======================================
1989 * 4ch
1990 * ======================================= */
1991void __bea_callspec__ dec_esp(PDISASM pMyDisasm)
1992{
1993 if (GV.Architecture == 64) {
1994 if (!Security(0, pMyDisasm)) return;
1995 GV.REX.W_ = 1;
1996 GV.REX.R_ = 1;
1997 GV.REX.X_ = 0;
1998 GV.REX.B_ = 0;
1999 GV.REX.state = InUsePrefix;
2000 GV.EIP_++;
2001 GV.NB_PREFIX++;
2002 (*pMyDisasm).Prefix.Number++;
2003 GV.OperandSize = 64;
2004 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2005 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2006 GV.OperandSize = 32;
2007
2008 }
2009 else {
2010 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2011 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2012 }
2013 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2014 #ifndef BEA_LIGHT_DISASSEMBLY
2015 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
2016 #endif
2017 if (GV.OperandSize == 32) {
2018 #ifndef BEA_LIGHT_DISASSEMBLY
2019 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4]);
2020 #endif
2021 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
2022 (*pMyDisasm).Argument1.ArgSize = 32;
2023 }
2024 else {
2025 #ifndef BEA_LIGHT_DISASSEMBLY
2026 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4]);
2027 #endif
2028 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
2029 (*pMyDisasm).Argument1.ArgSize = 16;
2030 }
2031 GV.EIP_++;
2032 FillFlags(pMyDisasm, 30);
2033 }
2034}
2035
2036/* =======================================
2037 * 4dh
2038 * ======================================= */
2039void __bea_callspec__ dec_ebp(PDISASM pMyDisasm)
2040{
2041 if (GV.Architecture == 64) {
2042 if (!Security(0, pMyDisasm)) return;
2043 GV.REX.W_ = 1;
2044 GV.REX.R_ = 1;
2045 GV.REX.X_ = 0;
2046 GV.REX.B_ = 1;
2047 GV.REX.state = InUsePrefix;
2048 GV.EIP_++;
2049 GV.NB_PREFIX++;
2050 (*pMyDisasm).Prefix.Number++;
2051 GV.OperandSize = 64;
2052 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2053 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2054 GV.OperandSize = 32;
2055
2056 }
2057 else {
2058 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2059 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2060 }
2061 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2062 #ifndef BEA_LIGHT_DISASSEMBLY
2063 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
2064 #endif
2065 if (GV.OperandSize == 32) {
2066 #ifndef BEA_LIGHT_DISASSEMBLY
2067 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5]);
2068 #endif
2069 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
2070 (*pMyDisasm).Argument1.ArgSize = 32;
2071 }
2072 else {
2073 #ifndef BEA_LIGHT_DISASSEMBLY
2074 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5]);
2075 #endif
2076 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
2077 (*pMyDisasm).Argument1.ArgSize = 16;
2078 }
2079 GV.EIP_++;
2080 FillFlags(pMyDisasm, 30);
2081 }
2082}
2083
2084/* =======================================
2085 * 4eh
2086 * ======================================= */
2087void __bea_callspec__ dec_esi(PDISASM pMyDisasm)
2088{
2089 if (GV.Architecture == 64) {
2090 if (!Security(0, pMyDisasm)) return;
2091 GV.REX.W_ = 1;
2092 GV.REX.R_ = 1;
2093 GV.REX.X_ = 1;
2094 GV.REX.B_ = 0;
2095 GV.REX.state = InUsePrefix;
2096 GV.EIP_++;
2097 GV.NB_PREFIX++;
2098 (*pMyDisasm).Prefix.Number++;
2099 GV.OperandSize = 64;
2100 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2101 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2102 GV.OperandSize = 32;
2103
2104 }
2105 else {
2106 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2107 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2108 }
2109 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2110 #ifndef BEA_LIGHT_DISASSEMBLY
2111 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
2112 #endif
2113 if (GV.OperandSize == 32) {
2114 #ifndef BEA_LIGHT_DISASSEMBLY
2115 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6]);
2116 #endif
2117 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
2118 (*pMyDisasm).Argument1.ArgSize = 32;
2119 }
2120 else {
2121 #ifndef BEA_LIGHT_DISASSEMBLY
2122 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6]);
2123 #endif
2124 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
2125 (*pMyDisasm).Argument1.ArgSize = 16;
2126 }
2127 GV.EIP_++;
2128 FillFlags(pMyDisasm, 30);
2129 }
2130}
2131
2132/* =======================================
2133 * 4fh
2134 * ======================================= */
2135void __bea_callspec__ dec_edi(PDISASM pMyDisasm)
2136{
2137 if (GV.Architecture == 64) {
2138 if (!Security(0, pMyDisasm)) return;
2139 GV.REX.W_ = 1;
2140 GV.REX.R_ = 1;
2141 GV.REX.X_ = 1;
2142 GV.REX.B_ = 1;
2143 GV.REX.state = InUsePrefix;
2144 GV.EIP_++;
2145 GV.NB_PREFIX++;
2146 (*pMyDisasm).Prefix.Number++;
2147 GV.OperandSize = 64;
2148 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2149 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2150 GV.OperandSize = 32;
2151
2152 }
2153 else {
2154 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2155 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2156 }
2157 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2158 #ifndef BEA_LIGHT_DISASSEMBLY
2159 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dec ");
2160 #endif
2161 if (GV.OperandSize == 32) {
2162 #ifndef BEA_LIGHT_DISASSEMBLY
2163 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7]);
2164 #endif
2165 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
2166 (*pMyDisasm).Argument1.ArgSize = 32;
2167 }
2168 else {
2169 #ifndef BEA_LIGHT_DISASSEMBLY
2170 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7]);
2171 #endif
2172 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
2173 (*pMyDisasm).Argument1.ArgSize = 16;
2174 }
2175 GV.EIP_++;
2176 FillFlags(pMyDisasm, 30);
2177 }
2178}
2179
2180/* =======================================
2181 * 0c8h
2182 * ======================================= */
2183void __bea_callspec__ enter_(PDISASM pMyDisasm)
2184{
2185 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2186 #ifndef BEA_LIGHT_DISASSEMBLY
2187 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "enter ");
2188 #endif
2189 #ifndef BEA_LIGHT_DISASSEMBLY
2190 (void) CopyFormattedNumber (pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic,"%.4X",(Int64) *((UInt16*)(UIntPtr) (GV.EIP_+1)));
2191 #endif
2192 (*pMyDisasm).Argument1.ArgSize = 16;
2193 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2194 #ifndef BEA_LIGHT_DISASSEMBLY
2195 (void) CopyFormattedNumber (pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_+3)));
2196 #endif
2197 (*pMyDisasm).Argument2.ArgSize = 8;
2198 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2199 GV.EIP_+=4;
2200}
2201
2202/* =======================================
2203 *
2204 * ======================================= */
2205void __bea_callspec__ femms_(PDISASM pMyDisasm)
2206{
2207 (*pMyDisasm).Instruction.Category = AMD_INSTRUCTION;
2208 #ifndef BEA_LIGHT_DISASSEMBLY
2209 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "femms ");
2210 #endif
2211 GV.EIP_++;
2212}
2213
2214/* =======================================
2215 *
2216 * ======================================= */
2217void __bea_callspec__ hlt_(PDISASM pMyDisasm)
2218{
2219 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
2220 #ifndef BEA_LIGHT_DISASSEMBLY
2221 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hlt ");
2222 #endif
2223 GV.EIP_++;
2224}
2225
2226/* =======================================
2227 *
2228 * ======================================= */
2229void __bea_callspec__ invd_(PDISASM pMyDisasm)
2230{
2231 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
2232 #ifndef BEA_LIGHT_DISASSEMBLY
2233 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "invd ");
2234 #endif
2235 GV.EIP_++;
2236}
2237
2238/* =======================================
2239 * 40h
2240 * ======================================= */
2241void __bea_callspec__ inc_eax(PDISASM pMyDisasm)
2242{
2243 if (GV.Architecture == 64) {
2244 if (!Security(0, pMyDisasm)) return;
2245 GV.REX.W_ = 0;
2246 GV.REX.R_ = 0;
2247 GV.REX.X_ = 0;
2248 GV.REX.B_ = 0;
2249 GV.REX.state = InUsePrefix;
2250 GV.EIP_++;
2251 GV.NB_PREFIX++;
2252 (*pMyDisasm).Prefix.Number++;
2253 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2254 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2255 GV.OperandSize = 32;
2256
2257 }
2258 else {
2259 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2260 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2261 }
2262 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2263 #ifndef BEA_LIGHT_DISASSEMBLY
2264 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2265 #endif
2266 if (GV.OperandSize == 32) {
2267 #ifndef BEA_LIGHT_DISASSEMBLY
2268 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
2269 #endif
2270 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2271 (*pMyDisasm).Argument1.ArgSize = 32;
2272 }
2273 else {
2274 #ifndef BEA_LIGHT_DISASSEMBLY
2275 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
2276 #endif
2277 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2278 (*pMyDisasm).Argument1.ArgSize = 16;
2279 }
2280 GV.EIP_++;
2281 FillFlags(pMyDisasm, 40);
2282 }
2283}
2284
2285/* =======================================
2286 * 41h
2287 * ======================================= */
2288void __bea_callspec__ inc_ecx(PDISASM pMyDisasm)
2289{
2290 if (GV.Architecture == 64) {
2291 if (!Security(0, pMyDisasm)) return;
2292 GV.REX.W_ = 0;
2293 GV.REX.R_ = 0;
2294 GV.REX.X_ = 0;
2295 GV.REX.B_ = 1;
2296 GV.REX.state = InUsePrefix;
2297 GV.EIP_++;
2298 GV.NB_PREFIX++;
2299 (*pMyDisasm).Prefix.Number++;
2300 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2301 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2302 GV.OperandSize = 32;
2303
2304 }
2305 else {
2306 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2307 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2308 }
2309 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2310 #ifndef BEA_LIGHT_DISASSEMBLY
2311 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2312 #endif
2313 if (GV.OperandSize == 32) {
2314 #ifndef BEA_LIGHT_DISASSEMBLY
2315 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1]);
2316 #endif
2317 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
2318 (*pMyDisasm).Argument1.ArgSize = 32;
2319 }
2320 else {
2321 #ifndef BEA_LIGHT_DISASSEMBLY
2322 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1]);
2323 #endif
2324 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[1+0];
2325 (*pMyDisasm).Argument1.ArgSize = 16;
2326 }
2327 GV.EIP_++;
2328 FillFlags(pMyDisasm, 40);
2329 }
2330}
2331
2332/* =======================================
2333 * 42h
2334 * ======================================= */
2335void __bea_callspec__ inc_edx(PDISASM pMyDisasm)
2336{
2337 if (GV.Architecture == 64) {
2338 if (!Security(0, pMyDisasm)) return;
2339 GV.REX.W_ = 0;
2340 GV.REX.R_ = 0;
2341 GV.REX.X_ = 1;
2342 GV.REX.B_ = 0;
2343 GV.REX.state = InUsePrefix;
2344 GV.EIP_++;
2345 GV.NB_PREFIX++;
2346 (*pMyDisasm).Prefix.Number++;
2347 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2348 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2349 GV.OperandSize = 32;
2350
2351 }
2352 else {
2353 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2354 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2355 }
2356 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2357 #ifndef BEA_LIGHT_DISASSEMBLY
2358 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2359 #endif
2360 if (GV.OperandSize == 32) {
2361 #ifndef BEA_LIGHT_DISASSEMBLY
2362 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2]);
2363 #endif
2364 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
2365 (*pMyDisasm).Argument1.ArgSize = 32;
2366 }
2367 else {
2368 #ifndef BEA_LIGHT_DISASSEMBLY
2369 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2]);
2370 #endif
2371 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2+0];
2372 (*pMyDisasm).Argument1.ArgSize = 16;
2373 }
2374 GV.EIP_++;
2375 FillFlags(pMyDisasm, 40);
2376 }
2377}
2378
2379/* =======================================
2380 * 43h
2381 * ======================================= */
2382void __bea_callspec__ inc_ebx(PDISASM pMyDisasm)
2383{
2384 if (GV.Architecture == 64) {
2385 if (!Security(0, pMyDisasm)) return;
2386 GV.REX.W_ = 0;
2387 GV.REX.R_ = 0;
2388 GV.REX.X_ = 1;
2389 GV.REX.B_ = 1;
2390 GV.REX.state = InUsePrefix;
2391 GV.EIP_++;
2392 GV.NB_PREFIX++;
2393 (*pMyDisasm).Prefix.Number++;
2394 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2395 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2396 GV.OperandSize = 32;
2397
2398 }
2399 else {
2400 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2401 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2402 }
2403 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2404 #ifndef BEA_LIGHT_DISASSEMBLY
2405 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2406 #endif
2407 if (GV.OperandSize == 32) {
2408 #ifndef BEA_LIGHT_DISASSEMBLY
2409 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3]);
2410 #endif
2411 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
2412 (*pMyDisasm).Argument1.ArgSize = 32;
2413 }
2414 else {
2415 #ifndef BEA_LIGHT_DISASSEMBLY
2416 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3]);
2417 #endif
2418 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[3+0];
2419 (*pMyDisasm).Argument1.ArgSize = 16;
2420 }
2421 GV.EIP_++;
2422 FillFlags(pMyDisasm, 40);
2423 }
2424}
2425
2426/* =======================================
2427 * 44h
2428 * ======================================= */
2429void __bea_callspec__ inc_esp(PDISASM pMyDisasm)
2430{
2431 if (GV.Architecture == 64) {
2432 if (!Security(0, pMyDisasm)) return;
2433 GV.REX.W_ = 0;
2434 GV.REX.R_ = 1;
2435 GV.REX.X_ = 0;
2436 GV.REX.B_ = 0;
2437 GV.REX.state = InUsePrefix;
2438 GV.EIP_++;
2439 GV.NB_PREFIX++;
2440 (*pMyDisasm).Prefix.Number++;
2441 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2442 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2443 GV.OperandSize = 32;
2444
2445 }
2446 else {
2447 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2448 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2449 }
2450 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2451 #ifndef BEA_LIGHT_DISASSEMBLY
2452 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2453 #endif
2454 if (GV.OperandSize == 32) {
2455 #ifndef BEA_LIGHT_DISASSEMBLY
2456 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4]);
2457 #endif
2458 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
2459 (*pMyDisasm).Argument1.ArgSize = 32;
2460 }
2461 else {
2462 #ifndef BEA_LIGHT_DISASSEMBLY
2463 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4]);
2464 #endif
2465 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[4+0];
2466 (*pMyDisasm).Argument1.ArgSize = 16;
2467 }
2468 GV.EIP_++;
2469 FillFlags(pMyDisasm, 40);
2470 }
2471}
2472
2473/* =======================================
2474 * 45h
2475 * ======================================= */
2476void __bea_callspec__ inc_ebp(PDISASM pMyDisasm)
2477{
2478 if (GV.Architecture == 64) {
2479 if (!Security(0, pMyDisasm)) return;
2480 GV.REX.W_ = 0;
2481 GV.REX.R_ = 1;
2482 GV.REX.X_ = 0;
2483 GV.REX.B_ = 1;
2484 GV.REX.state = InUsePrefix;
2485 GV.EIP_++;
2486 GV.NB_PREFIX++;
2487 (*pMyDisasm).Prefix.Number++;
2488 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2489 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2490 GV.OperandSize = 32;
2491
2492 }
2493 else {
2494 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2495 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2496 }
2497 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2498 #ifndef BEA_LIGHT_DISASSEMBLY
2499 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2500 #endif
2501 if (GV.OperandSize == 32) {
2502 #ifndef BEA_LIGHT_DISASSEMBLY
2503 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5]);
2504 #endif
2505 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
2506 (*pMyDisasm).Argument1.ArgSize = 32;
2507 }
2508 else {
2509 #ifndef BEA_LIGHT_DISASSEMBLY
2510 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5]);
2511 #endif
2512 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[5+0];
2513 (*pMyDisasm).Argument1.ArgSize = 16;
2514 }
2515 GV.EIP_++;
2516 FillFlags(pMyDisasm, 40);
2517 }
2518}
2519
2520/* =======================================
2521 * 46h
2522 * ======================================= */
2523void __bea_callspec__ inc_esi(PDISASM pMyDisasm)
2524{
2525 if (GV.Architecture == 64) {
2526 if (!Security(0, pMyDisasm)) return;
2527 GV.REX.W_ = 0;
2528 GV.REX.R_ = 1;
2529 GV.REX.X_ = 1;
2530 GV.REX.B_ = 0;
2531 GV.REX.state = InUsePrefix;
2532 GV.EIP_++;
2533 GV.NB_PREFIX++;
2534 (*pMyDisasm).Prefix.Number++;
2535 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2536 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2537 GV.OperandSize = 32;
2538
2539 }
2540 else {
2541 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2542 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2543 }
2544 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2545 #ifndef BEA_LIGHT_DISASSEMBLY
2546 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2547 #endif
2548 if (GV.OperandSize == 32) {
2549 #ifndef BEA_LIGHT_DISASSEMBLY
2550 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6]);
2551 #endif
2552 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
2553 (*pMyDisasm).Argument1.ArgSize = 32;
2554 }
2555 else {
2556 #ifndef BEA_LIGHT_DISASSEMBLY
2557 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6]);
2558 #endif
2559 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[6+0];
2560 (*pMyDisasm).Argument1.ArgSize = 16;
2561 }
2562 GV.EIP_++;
2563 FillFlags(pMyDisasm, 40);
2564 }
2565}
2566
2567/* =======================================
2568 * 47h
2569 * ======================================= */
2570void __bea_callspec__ inc_edi(PDISASM pMyDisasm)
2571{
2572 if (GV.Architecture == 64) {
2573 if (!Security(0, pMyDisasm)) return;
2574 GV.REX.W_ = 0;
2575 GV.REX.R_ = 1;
2576 GV.REX.X_ = 1;
2577 GV.REX.B_ = 1;
2578 GV.REX.state = InUsePrefix;
2579 GV.EIP_++;
2580 GV.NB_PREFIX++;
2581 (*pMyDisasm).Prefix.Number++;
2582 (*pMyDisasm).Instruction.Opcode = *((UInt8*) (UIntPtr)GV.EIP_);
2583 (void) opcode_map1[*((UInt8*) (UIntPtr)GV.EIP_)](pMyDisasm);
2584 GV.OperandSize = 32;
2585
2586 }
2587 else {
2588 if ((*pMyDisasm).Prefix.LockPrefix == InvalidPrefix) {
2589 (*pMyDisasm).Prefix.LockPrefix = InUsePrefix;
2590 }
2591 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2592 #ifndef BEA_LIGHT_DISASSEMBLY
2593 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "inc ");
2594 #endif
2595 if (GV.OperandSize == 32) {
2596 #ifndef BEA_LIGHT_DISASSEMBLY
2597 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7]);
2598 #endif
2599 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
2600 (*pMyDisasm).Argument1.ArgSize = 32;
2601 }
2602 else {
2603 #ifndef BEA_LIGHT_DISASSEMBLY
2604 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7]);
2605 #endif
2606 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[7+0];
2607 (*pMyDisasm).Argument1.ArgSize = 16;
2608 }
2609 GV.EIP_++;
2610 FillFlags(pMyDisasm, 40);
2611 }
2612}
2613/* =======================================
2614 * 0xcf
2615 * ======================================= */
2616void __bea_callspec__ iret_(PDISASM pMyDisasm)
2617{
2618 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2619 (*pMyDisasm).Instruction.BranchType = RetType;
2620 if (GV.OperandSize ==64) {
2621 #ifndef BEA_LIGHT_DISASSEMBLY
2622 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "iretq ");
2623 #endif
2624 }
2625 else if (GV.OperandSize == 32) {
2626 #ifndef BEA_LIGHT_DISASSEMBLY
2627 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "iretd ");
2628 #endif
2629 }
2630 else {
2631 #ifndef BEA_LIGHT_DISASSEMBLY
2632 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "iretw ");
2633 #endif
2634 }
2635 GV.EIP_++;
2636}
2637
2638/* =======================================
2639 *
2640 * ======================================= */
2641void __bea_callspec__ in_ALDX(PDISASM pMyDisasm)
2642{
2643 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2644 #ifndef BEA_LIGHT_DISASSEMBLY
2645 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
2646 #endif
2647 #ifndef BEA_LIGHT_DISASSEMBLY
2648 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0]);
2649 #endif
2650 #ifndef BEA_LIGHT_DISASSEMBLY
2651 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
2652 #endif
2653 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2654 (*pMyDisasm).Argument1.ArgSize = 8;
2655 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
2656 (*pMyDisasm).Argument2.ArgSize = 16;
2657 GV.EIP_++;
2658}
2659
2660/* =======================================
2661 *
2662 * ======================================= */
2663void __bea_callspec__ in_ALIb(PDISASM pMyDisasm)
2664{
2665 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2666 #ifndef BEA_LIGHT_DISASSEMBLY
2667 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
2668 #endif
2669 ALIb(pMyDisasm);
2670}
2671
2672/* =======================================
2673 * 0xe5
2674 * ======================================= */
2675void __bea_callspec__ in_eAX_Ib(PDISASM pMyDisasm)
2676{
2677 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2678 #ifndef BEA_LIGHT_DISASSEMBLY
2679 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
2680 #endif
2681 if (!Security(1, pMyDisasm)) return;
2682 GV.ImmediatSize = 8;
2683 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_+1));
2684 #ifndef BEA_LIGHT_DISASSEMBLY
2685 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_+1)));
2686 #endif
2687 #ifndef BEA_LIGHT_DISASSEMBLY
2688 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
2689 #endif
2690 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2691 (*pMyDisasm).Argument1.ArgSize = 32;
2692 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2693 (*pMyDisasm).Argument2.ArgSize = 8;
2694 GV.EIP_+=2;
2695}
2696
2697/* =======================================
2698 *
2699 * ======================================= */
2700void __bea_callspec__ insb_(PDISASM pMyDisasm)
2701{
2702 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2703 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2704 }
2705 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2706 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2707 }
2708 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2709 #ifndef BEA_LIGHT_DISASSEMBLY
2710 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "insb ");
2711 #endif
2712 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2713 (*pMyDisasm).Argument1.ArgSize = 8;
2714 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2715 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
2716 (*pMyDisasm).Argument2.ArgSize = 16;
2717 GV.EIP_++;
2718 FillFlags(pMyDisasm, 41);
2719
2720
2721}
2722
2723/* =======================================
2724 *
2725 * ======================================= */
2726void __bea_callspec__ ins_(PDISASM pMyDisasm)
2727{
2728 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
2729 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
2730 }
2731 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
2732 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
2733 }
2734 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2735 if (GV.OperandSize >= 32) {
2736 #ifndef BEA_LIGHT_DISASSEMBLY
2737 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "insd ");
2738 #endif
2739 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2740 (*pMyDisasm).Argument1.ArgSize = 32;
2741 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2742 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
2743 (*pMyDisasm).Argument2.ArgSize = 16;
2744 GV.EIP_++;
2745 FillFlags(pMyDisasm, 41);
2746 }
2747 else {
2748 #ifndef BEA_LIGHT_DISASSEMBLY
2749 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "insw ");
2750 #endif
2751 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
2752 (*pMyDisasm).Argument1.ArgSize = 16;
2753 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
2754 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
2755 (*pMyDisasm).Argument2.ArgSize = 16;
2756 GV.EIP_++;
2757 FillFlags(pMyDisasm, 41);
2758 }
2759}
2760
2761/* =======================================
2762 *
2763 * ======================================= */
2764void __bea_callspec__ into_(PDISASM pMyDisasm)
2765{
2766 if (GV.Architecture == 64) {
2767 FailDecode(pMyDisasm);
2768 }
2769 else {
2770 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2771 #ifndef BEA_LIGHT_DISASSEMBLY
2772 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "into ");
2773 #endif
2774 GV.EIP_++;
2775 FillFlags(pMyDisasm, 43);
2776 }
2777}
2778
2779/* =======================================
2780 * 0edh
2781 * ======================================= */
2782void __bea_callspec__ in_eAX(PDISASM pMyDisasm)
2783{
2784 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+InOutINSTRUCTION;
2785 #ifndef BEA_LIGHT_DISASSEMBLY
2786 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "in ");
2787 #endif
2788 if (GV.OperandSize >=32) {
2789 #ifndef BEA_LIGHT_DISASSEMBLY
2790 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
2791 #endif
2792 #ifndef BEA_LIGHT_DISASSEMBLY
2793 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
2794 #endif
2795 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2796 (*pMyDisasm).Argument1.ArgSize = 32;
2797 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
2798 (*pMyDisasm).Argument2.ArgSize = 16;
2799 }
2800 else {
2801 #ifndef BEA_LIGHT_DISASSEMBLY
2802 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
2803 #endif
2804 #ifndef BEA_LIGHT_DISASSEMBLY
2805 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[2]);
2806 #endif
2807 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[0];
2808 (*pMyDisasm).Argument1.ArgSize = 16;
2809 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REGS[2];
2810 (*pMyDisasm).Argument2.ArgSize = 16;
2811 }
2812 GV.EIP_++;
2813}
2814
2815/* =======================================
2816 * 0cdh
2817 * ======================================= */
2818void __bea_callspec__ int_(PDISASM pMyDisasm)
2819{
2820 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2821 #ifndef BEA_LIGHT_DISASSEMBLY
2822 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "int ");
2823 #endif
2824 if (!Security(1, pMyDisasm)) return;
2825 GV.ImmediatSize = 8;
2826 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_+1));
2827 #ifndef BEA_LIGHT_DISASSEMBLY
2828 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_+1)));
2829 #endif
2830 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2831 (*pMyDisasm).Argument1.ArgSize = 8;
2832 GV.EIP_+=2;
2833 FillFlags(pMyDisasm, 42);
2834}
2835
2836/* =======================================
2837 * 0f1h
2838 * ======================================= */
2839void __bea_callspec__ int1_(PDISASM pMyDisasm)
2840{
2841 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2842 #ifndef BEA_LIGHT_DISASSEMBLY
2843 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "int1 ");
2844 #endif
2845 GV.EIP_++;
2846 FillFlags(pMyDisasm, 42);
2847}
2848
2849/* =======================================
2850 * 0cch
2851 * ======================================= */
2852void __bea_callspec__ int3_(PDISASM pMyDisasm)
2853{
2854 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2855 #ifndef BEA_LIGHT_DISASSEMBLY
2856 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "int3 ");
2857 #endif
2858 GV.EIP_++;
2859 FillFlags(pMyDisasm, 42);
2860}
2861
2862/* =======================================
2863 * 69h
2864 * ======================================= */
2865void __bea_callspec__ imul_GvEvIv(PDISASM pMyDisasm)
2866{
2867 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2868 #ifndef BEA_LIGHT_DISASSEMBLY
2869 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
2870 #endif
2871 if (GV.OperandSize >= 32) {
2872 if (GV.OperandSize == 64) {
2873 GV.MemDecoration = Arg2qword;
2874 }
2875 else {
2876 GV.MemDecoration = Arg2dword;
2877 }
2878 GV.ImmediatSize = 32;
2879 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2880 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2881 GV.EIP_+= GV.DECALAGE_EIP+6;
2882 if (!Security(0, pMyDisasm)) return;
2883 GV.third_arg = 1;
2884 (*pMyDisasm).Instruction.Immediat = *((UInt32*)(UIntPtr) (GV.EIP_- 4));
2885 #ifndef BEA_LIGHT_DISASSEMBLY
2886 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.8X",(Int64) *((UInt32*)(UIntPtr) (GV.EIP_- 4)));
2887 #endif
2888 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2889 (*pMyDisasm).Argument3.ArgSize = 32;
2890
2891 FillFlags(pMyDisasm, 38);
2892 }
2893 else {
2894 GV.MemDecoration = Arg2word;
2895 GV.ImmediatSize = 16;
2896 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2897 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2898 GV.EIP_+= GV.DECALAGE_EIP+4;
2899 if (!Security(0, pMyDisasm)) return;
2900 GV.third_arg = 1;
2901 (*pMyDisasm).Instruction.Immediat = *((UInt16*)(UIntPtr) (GV.EIP_- 2));
2902 #ifndef BEA_LIGHT_DISASSEMBLY
2903 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.4X",(Int64) *((UInt16*)(UIntPtr) (GV.EIP_- 2)));
2904 #endif
2905 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2906 (*pMyDisasm).Argument3.ArgSize = 16;
2907
2908 FillFlags(pMyDisasm, 38);
2909 }
2910}
2911
2912/* =======================================
2913 * 6bh
2914 * ======================================= */
2915void __bea_callspec__ imul_GvEvIb(PDISASM pMyDisasm)
2916{
2917 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2918 #ifndef BEA_LIGHT_DISASSEMBLY
2919 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
2920 #endif
2921 if (GV.OperandSize >= 32) {
2922 if (GV.OperandSize == 64) {
2923 GV.MemDecoration = Arg2qword;
2924 }
2925 else {
2926 GV.MemDecoration = Arg2dword;
2927 }
2928 GV.ImmediatSize = 8;
2929 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2930 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2931 GV.EIP_+= GV.DECALAGE_EIP+3;
2932 if (!Security(0, pMyDisasm)) return;
2933 GV.third_arg = 1;
2934 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2935 #ifndef BEA_LIGHT_DISASSEMBLY
2936 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2937 #endif
2938 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2939 (*pMyDisasm).Argument3.ArgSize = 8;
2940
2941 FillFlags(pMyDisasm, 38);
2942 }
2943 else {
2944 GV.MemDecoration = Arg2word;
2945 GV.ImmediatSize = 8;
2946 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2947 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2948 GV.EIP_+= GV.DECALAGE_EIP+3;
2949 if (!Security(0, pMyDisasm)) return;
2950 GV.third_arg = 1;
2951 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2952 #ifndef BEA_LIGHT_DISASSEMBLY
2953 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2954 #endif
2955 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2956 (*pMyDisasm).Argument3.ArgSize = 8;
2957
2958 FillFlags(pMyDisasm, 38);
2959 }
2960}
2961
2962/* =======================================
2963 * 0fafh
2964 * ======================================= */
2965void __bea_callspec__ imul_GvEv(PDISASM pMyDisasm)
2966{
2967
2968 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2969 #ifndef BEA_LIGHT_DISASSEMBLY
2970 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "imul ");
2971 #endif
2972 GvEv(pMyDisasm);
2973 FillFlags(pMyDisasm,38);
2974}
2975
2976/* =======================================
2977 * 70h
2978 * ======================================= */
2979void __bea_callspec__ jo_(PDISASM pMyDisasm)
2980{
2981 UInt64 MyAddress;
2982
2983 signed long MyNumber;
2984 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
2985 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
2986 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
2987 }
2988 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
2989 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
2990 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
2991 }
2992 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
2993 (*pMyDisasm).Instruction.BranchType = JO;
2994 #ifndef BEA_LIGHT_DISASSEMBLY
2995 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jo ");
2996 #endif
2997 if (!Security(1, pMyDisasm)) return;
2998 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
2999 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3000 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3001 if (MyAddress >= W64LIT (0x100000000)) {
3002 #ifndef BEA_LIGHT_DISASSEMBLY
3003 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3004 #endif
3005 }
3006 else {
3007 #ifndef BEA_LIGHT_DISASSEMBLY
3008 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3009 #endif
3010 }
3011 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3012 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3013 (*pMyDisasm).Argument1.AccessMode = READ;
3014 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3015 GV.EIP_+=2;
3016 FillFlags(pMyDisasm,116);
3017}
3018
3019/* =======================================
3020 * 71h
3021 * ======================================= */
3022void __bea_callspec__ jno_(PDISASM pMyDisasm)
3023{
3024 UInt64 MyAddress;
3025 signed long MyNumber;
3026 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3027 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3028 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3029 }
3030 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3031 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3032 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3033 }
3034 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3035 (*pMyDisasm).Instruction.BranchType = JNO;
3036 #ifndef BEA_LIGHT_DISASSEMBLY
3037 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jno ");
3038 #endif
3039 if (!Security(1, pMyDisasm)) return;
3040 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3041 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3042 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3043 if (MyAddress >= W64LIT (0x100000000)) {
3044 #ifndef BEA_LIGHT_DISASSEMBLY
3045 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3046 #endif
3047 }
3048 else {
3049 #ifndef BEA_LIGHT_DISASSEMBLY
3050 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3051 #endif
3052 }
3053 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3054 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3055 (*pMyDisasm).Argument1.AccessMode = READ;
3056 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3057 GV.EIP_+=2;
3058 FillFlags(pMyDisasm,116);
3059}
3060
3061/* =======================================
3062 * 72h
3063 * ======================================= */
3064void __bea_callspec__ jc_(PDISASM pMyDisasm)
3065{
3066 UInt64 MyAddress;
3067 signed long MyNumber;
3068 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3069 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3070 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3071 }
3072 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3073 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3074 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3075 }
3076 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3077 (*pMyDisasm).Instruction.BranchType = JC;
3078 #ifndef BEA_LIGHT_DISASSEMBLY
3079 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jc ");
3080 #endif
3081 if (!Security(1, pMyDisasm)) return;
3082 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3083 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3084 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3085 if (MyAddress >= W64LIT (0x100000000)) {
3086 #ifndef BEA_LIGHT_DISASSEMBLY
3087 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3088 #endif
3089 }
3090 else {
3091 #ifndef BEA_LIGHT_DISASSEMBLY
3092 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3093 #endif
3094 }
3095 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3096 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3097 (*pMyDisasm).Argument1.AccessMode = READ;
3098 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3099 GV.EIP_+=2;
3100 FillFlags(pMyDisasm,117);
3101}
3102
3103/* =======================================
3104 * 73h
3105 * ======================================= */
3106void __bea_callspec__ jnc_(PDISASM pMyDisasm)
3107{
3108 UInt64 MyAddress;
3109 signed long MyNumber;
3110 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3111 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3112 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3113 }
3114 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3115 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3116 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3117 }
3118 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3119 (*pMyDisasm).Instruction.BranchType = JNC;
3120 #ifndef BEA_LIGHT_DISASSEMBLY
3121 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnc ");
3122 #endif
3123 if (!Security(1, pMyDisasm)) return;
3124 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3125 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3126 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3127 if (MyAddress >= W64LIT (0x100000000)) {
3128 #ifndef BEA_LIGHT_DISASSEMBLY
3129 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3130 #endif
3131 }
3132 else {
3133 #ifndef BEA_LIGHT_DISASSEMBLY
3134 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3135 #endif
3136 }
3137 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3138 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3139 (*pMyDisasm).Argument1.AccessMode = READ;
3140 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3141 GV.EIP_+=2;
3142 FillFlags(pMyDisasm,117);
3143}
3144/* =======================================
3145 * 74h
3146 * ======================================= */
3147void __bea_callspec__ je_(PDISASM pMyDisasm)
3148{
3149 UInt64 MyAddress;
3150 signed long MyNumber;
3151 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3152 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3153 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3154 }
3155 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3156 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3157 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3158 }
3159 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3160 (*pMyDisasm).Instruction.BranchType = JE;
3161 #ifndef BEA_LIGHT_DISASSEMBLY
3162 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "je ");
3163 #endif
3164 if (!Security(1, pMyDisasm)) return;
3165 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3166 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3167 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3168 if (MyAddress >= W64LIT (0x100000000)) {
3169 #ifndef BEA_LIGHT_DISASSEMBLY
3170 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3171 #endif
3172 }
3173 else {
3174 #ifndef BEA_LIGHT_DISASSEMBLY
3175 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3176 #endif
3177 }
3178 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3179 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3180 (*pMyDisasm).Argument1.AccessMode = READ;
3181 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3182 GV.EIP_+=2;
3183 FillFlags(pMyDisasm,118);
3184}
3185
3186/* =======================================
3187 * 75h
3188 * ======================================= */
3189void __bea_callspec__ jne_(PDISASM pMyDisasm)
3190{
3191 UInt64 MyAddress;
3192 signed long MyNumber;
3193 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3194 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3195 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3196 }
3197 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3198 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3199 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3200 }
3201 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3202 (*pMyDisasm).Instruction.BranchType = JNE;
3203 #ifndef BEA_LIGHT_DISASSEMBLY
3204 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jne ");
3205 #endif
3206 if (!Security(1, pMyDisasm)) return;
3207 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3208 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3209 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3210 if (MyAddress >= W64LIT (0x100000000)) {
3211 #ifndef BEA_LIGHT_DISASSEMBLY
3212 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3213 #endif
3214 }
3215 else {
3216 #ifndef BEA_LIGHT_DISASSEMBLY
3217 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3218 #endif
3219 }
3220 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3221 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3222 (*pMyDisasm).Argument1.AccessMode = READ;
3223 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3224 GV.EIP_+=2;
3225 FillFlags(pMyDisasm,49);
3226}
3227
3228/* =======================================
3229 * 76h
3230 * ======================================= */
3231void __bea_callspec__ jbe_(PDISASM pMyDisasm)
3232{
3233 UInt64 MyAddress;
3234 signed long MyNumber;
3235 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3236 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3237 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3238 }
3239 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3240 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3241 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3242 }
3243 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3244 (*pMyDisasm).Instruction.BranchType = JNA;
3245 #ifndef BEA_LIGHT_DISASSEMBLY
3246 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jbe ");
3247 #endif
3248 if (!Security(1, pMyDisasm)) return;
3249 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3250 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3251 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3252 if (MyAddress >= W64LIT (0x100000000)) {
3253 #ifndef BEA_LIGHT_DISASSEMBLY
3254 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3255 #endif
3256 }
3257 else {
3258 #ifndef BEA_LIGHT_DISASSEMBLY
3259 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3260 #endif
3261 }
3262 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3263 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3264 (*pMyDisasm).Argument1.AccessMode = READ;
3265 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3266 GV.EIP_+=2;
3267 FillFlags(pMyDisasm,119);
3268}
3269
3270/* =======================================
3271 * 77h
3272 * ======================================= */
3273void __bea_callspec__ jnbe_(PDISASM pMyDisasm)
3274{
3275 UInt64 MyAddress;
3276 signed long MyNumber;
3277 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3278 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3279 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3280 }
3281 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3282 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3283 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3284 }
3285 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3286 (*pMyDisasm).Instruction.BranchType = JA;
3287 #ifndef BEA_LIGHT_DISASSEMBLY
3288 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnbe ");
3289 #endif
3290 if (!Security(1, pMyDisasm)) return;
3291 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3292 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3293 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3294 if (MyAddress >= W64LIT (0x100000000)) {
3295 #ifndef BEA_LIGHT_DISASSEMBLY
3296 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3297 #endif
3298 }
3299 else {
3300 #ifndef BEA_LIGHT_DISASSEMBLY
3301 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3302 #endif
3303 }
3304 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3305 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3306 (*pMyDisasm).Argument1.AccessMode = READ;
3307 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3308 GV.EIP_+=2;
3309 FillFlags(pMyDisasm,119);
3310}
3311
3312/* =======================================
3313 * 78h
3314 * ======================================= */
3315void __bea_callspec__ js_(PDISASM pMyDisasm)
3316{
3317 UInt64 MyAddress;
3318 signed long MyNumber;
3319 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3320 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3321 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3322 }
3323 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3324 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3325 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3326 }
3327 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3328 (*pMyDisasm).Instruction.BranchType = JS;
3329 #ifndef BEA_LIGHT_DISASSEMBLY
3330 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "js ");
3331 #endif
3332 if (!Security(1, pMyDisasm)) return;
3333 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3334 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3335 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3336 if (MyAddress >= W64LIT (0x100000000)) {
3337 #ifndef BEA_LIGHT_DISASSEMBLY
3338 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3339 #endif
3340 }
3341 else {
3342 #ifndef BEA_LIGHT_DISASSEMBLY
3343 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3344 #endif
3345 }
3346 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3347 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3348 (*pMyDisasm).Argument1.AccessMode = READ;
3349 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3350 GV.EIP_+=2;
3351 FillFlags(pMyDisasm,120);
3352}
3353
3354/* =======================================
3355 * 79h
3356 * ======================================= */
3357void __bea_callspec__ jns_(PDISASM pMyDisasm)
3358{
3359 UInt64 MyAddress;
3360 signed long MyNumber;
3361 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3362 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3363 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3364 }
3365 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3366 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3367 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3368 }
3369 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3370 (*pMyDisasm).Instruction.BranchType = JNS;
3371 #ifndef BEA_LIGHT_DISASSEMBLY
3372 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jns ");
3373 #endif
3374 if (!Security(1, pMyDisasm)) return;
3375 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3376 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3377 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3378 if (MyAddress >= W64LIT (0x100000000)) {
3379 #ifndef BEA_LIGHT_DISASSEMBLY
3380 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3381 #endif
3382 }
3383 else {
3384 #ifndef BEA_LIGHT_DISASSEMBLY
3385 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3386 #endif
3387 }
3388 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3389 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3390 (*pMyDisasm).Argument1.AccessMode = READ;
3391 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3392 GV.EIP_+=2;
3393 FillFlags(pMyDisasm,120);
3394}
3395
3396/* =======================================
3397 * 7ah
3398 * ======================================= */
3399void __bea_callspec__ jp_(PDISASM pMyDisasm)
3400{
3401 UInt64 MyAddress;
3402 signed long MyNumber;
3403 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3404 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3405 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3406 }
3407 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3408 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3409 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3410 }
3411 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3412 (*pMyDisasm).Instruction.BranchType = JP;
3413 #ifndef BEA_LIGHT_DISASSEMBLY
3414 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jp ");
3415 #endif
3416 if (!Security(1, pMyDisasm)) return;
3417 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3418 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3419 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3420 if (MyAddress >= W64LIT (0x100000000)) {
3421 #ifndef BEA_LIGHT_DISASSEMBLY
3422 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3423 #endif
3424 }
3425 else {
3426 #ifndef BEA_LIGHT_DISASSEMBLY
3427 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3428 #endif
3429 }
3430 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3431 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3432 (*pMyDisasm).Argument1.AccessMode = READ;
3433 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3434 GV.EIP_+=2;
3435 FillFlags(pMyDisasm,121);
3436}
3437
3438/* =======================================
3439 * 7bh
3440 * ======================================= */
3441void __bea_callspec__ jnp_(PDISASM pMyDisasm)
3442{
3443 UInt64 MyAddress;
3444 signed long MyNumber;
3445 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3446 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3447 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3448 }
3449 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3450 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3451 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3452 }
3453 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3454 (*pMyDisasm).Instruction.BranchType = JNP;
3455 #ifndef BEA_LIGHT_DISASSEMBLY
3456 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnp ");
3457 #endif
3458 if (!Security(1, pMyDisasm)) return;
3459 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3460 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3461 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3462 if (MyAddress >= W64LIT (0x100000000)) {
3463 #ifndef BEA_LIGHT_DISASSEMBLY
3464 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3465 #endif
3466 }
3467 else {
3468 #ifndef BEA_LIGHT_DISASSEMBLY
3469 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3470 #endif
3471 }
3472 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3473 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3474 (*pMyDisasm).Argument1.AccessMode = READ;
3475 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3476 GV.EIP_+=2;
3477 FillFlags(pMyDisasm,121);
3478}
3479
3480/* =======================================
3481 * 7ch
3482 * ======================================= */
3483void __bea_callspec__ jl_(PDISASM pMyDisasm)
3484{
3485 UInt64 MyAddress;
3486 signed long MyNumber;
3487 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3488 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3489 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3490 }
3491 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3492 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3493 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3494 }
3495 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3496 (*pMyDisasm).Instruction.BranchType = JL;
3497 #ifndef BEA_LIGHT_DISASSEMBLY
3498 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jl ");
3499 #endif
3500 if (!Security(1, pMyDisasm)) return;
3501 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3502 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3503 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3504 if (MyAddress >= W64LIT (0x100000000)) {
3505 #ifndef BEA_LIGHT_DISASSEMBLY
3506 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3507 #endif
3508 }
3509 else {
3510 #ifndef BEA_LIGHT_DISASSEMBLY
3511 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3512 #endif
3513 }
3514 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3515 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3516 (*pMyDisasm).Argument1.AccessMode = READ;
3517 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3518 GV.EIP_+=2;
3519 FillFlags(pMyDisasm,122);
3520}
3521
3522/* =======================================
3523 * 7dh
3524 * ======================================= */
3525void __bea_callspec__ jnl_(PDISASM pMyDisasm)
3526{
3527 UInt64 MyAddress;
3528 signed long MyNumber;
3529 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3530 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3531 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3532 }
3533 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3534 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3535 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3536 }
3537 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3538 (*pMyDisasm).Instruction.BranchType = JNL;
3539 #ifndef BEA_LIGHT_DISASSEMBLY
3540 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnl ");
3541 #endif
3542 if (!Security(1, pMyDisasm)) return;
3543 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3544 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3545 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3546 if (MyAddress >= W64LIT (0x100000000)) {
3547 #ifndef BEA_LIGHT_DISASSEMBLY
3548 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3549 #endif
3550 }
3551 else {
3552 #ifndef BEA_LIGHT_DISASSEMBLY
3553 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3554 #endif
3555 }
3556 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3557 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3558 (*pMyDisasm).Argument1.AccessMode = READ;
3559 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3560 GV.EIP_+=2;
3561 FillFlags(pMyDisasm,122);
3562}
3563
3564/* =======================================
3565 * 7eh
3566 * ======================================= */
3567void __bea_callspec__ jle_(PDISASM pMyDisasm)
3568{
3569 UInt64 MyAddress;
3570 signed long MyNumber;
3571 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3572 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3573 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3574 }
3575 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3576 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3577 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3578 }
3579 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3580 (*pMyDisasm).Instruction.BranchType = JNG;
3581 #ifndef BEA_LIGHT_DISASSEMBLY
3582 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jle ");
3583 #endif
3584 if (!Security(1, pMyDisasm)) return;
3585 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3586 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3587 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3588 if (MyAddress >= W64LIT (0x100000000)) {
3589 #ifndef BEA_LIGHT_DISASSEMBLY
3590 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3591 #endif
3592 }
3593 else {
3594 #ifndef BEA_LIGHT_DISASSEMBLY
3595 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3596 #endif
3597 }
3598 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3599 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3600 (*pMyDisasm).Argument1.AccessMode = READ;
3601 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3602 GV.EIP_+=2;
3603 FillFlags(pMyDisasm,115);
3604}
3605
3606/* =======================================
3607 * 7fh
3608 * ======================================= */
3609void __bea_callspec__ jnle_(PDISASM pMyDisasm)
3610{
3611 UInt64 MyAddress;
3612 signed long MyNumber;
3613 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3614 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3615 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3616 }
3617 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3618 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3619 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3620 }
3621 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3622 (*pMyDisasm).Instruction.BranchType = JG;
3623 #ifndef BEA_LIGHT_DISASSEMBLY
3624 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnle ");
3625 #endif
3626 if (!Security(1, pMyDisasm)) return;
3627 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
3628 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
3629 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
3630 if (MyAddress >= W64LIT (0x100000000)) {
3631 #ifndef BEA_LIGHT_DISASSEMBLY
3632 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3633 #endif
3634 }
3635 else {
3636 #ifndef BEA_LIGHT_DISASSEMBLY
3637 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3638 #endif
3639 }
3640 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3641 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3642 (*pMyDisasm).Argument1.AccessMode = READ;
3643 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3644 GV.EIP_+=2;
3645 FillFlags(pMyDisasm,115);
3646}
3647
3648
3649/* =======================================
3650 * 0f80h
3651 * ======================================= */
3652void __bea_callspec__ jo_near(PDISASM pMyDisasm)
3653{
3654 UInt64 MyAddress;
3655 long MyNumber;
3656 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3657 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3658 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3659 }
3660 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3661 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3662 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3663 }
3664 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3665 (*pMyDisasm).Instruction.BranchType = JO;
3666 #ifndef BEA_LIGHT_DISASSEMBLY
3667 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jo ");
3668 #endif
3669 if (GV.OperandSize >= 32) {
3670 if (!Security(5, pMyDisasm)) return;
3671 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3672 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3673 if (MyAddress >= W64LIT (0x100000000)) {
3674 #ifndef BEA_LIGHT_DISASSEMBLY
3675 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3676 #endif
3677 }
3678 else {
3679 #ifndef BEA_LIGHT_DISASSEMBLY
3680 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3681 #endif
3682 }
3683 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3684 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3685 (*pMyDisasm).Argument1.AccessMode = READ;
3686 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3687 GV.EIP_+=5;
3688 FillFlags(pMyDisasm,116);
3689 }
3690 else {
3691 if (!Security(3, pMyDisasm)) return;
3692 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3693 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3694 MyAddress = MyAddress & 0xffff;
3695 #ifndef BEA_LIGHT_DISASSEMBLY
3696 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3697 #endif
3698 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3699 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3700 (*pMyDisasm).Argument1.AccessMode = READ;
3701 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3702 GV.EIP_+=3;
3703 FillFlags(pMyDisasm,116);
3704 }
3705}
3706
3707
3708/* =======================================
3709 * 0f81h
3710 * ======================================= */
3711void __bea_callspec__ jno_near(PDISASM pMyDisasm)
3712{
3713 UInt64 MyAddress;
3714 long MyNumber;
3715 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3716 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3717 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3718 }
3719 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3720 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3721 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3722 }
3723 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3724 (*pMyDisasm).Instruction.BranchType = JNO;
3725 #ifndef BEA_LIGHT_DISASSEMBLY
3726 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jno ");
3727 #endif
3728 if (GV.OperandSize >= 32) {
3729 if (!Security(5, pMyDisasm)) return;
3730 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3731 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3732 if (MyAddress >= W64LIT (0x100000000)) {
3733 #ifndef BEA_LIGHT_DISASSEMBLY
3734 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3735 #endif
3736 }
3737 else {
3738 #ifndef BEA_LIGHT_DISASSEMBLY
3739 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3740 #endif
3741 }
3742 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3743 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3744 (*pMyDisasm).Argument1.AccessMode = READ;
3745 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3746 GV.EIP_+=5;
3747 FillFlags(pMyDisasm,116);
3748 }
3749 else {
3750 if (!Security(3, pMyDisasm)) return;
3751 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3752 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3753 MyAddress = MyAddress & 0xffff;
3754 #ifndef BEA_LIGHT_DISASSEMBLY
3755 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3756 #endif
3757 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3758 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3759 (*pMyDisasm).Argument1.AccessMode = READ;
3760 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3761 GV.EIP_+=3;
3762 FillFlags(pMyDisasm,116);
3763 }
3764}
3765
3766/* =======================================
3767 * 0f82h
3768 * ======================================= */
3769void __bea_callspec__ jc_near(PDISASM pMyDisasm)
3770{
3771 UInt64 MyAddress;
3772 long MyNumber;
3773 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3774 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3775 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3776 }
3777 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3778 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3779 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3780 }
3781 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3782 (*pMyDisasm).Instruction.BranchType = JC;
3783 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3784 #ifndef BEA_LIGHT_DISASSEMBLY
3785 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jc ");
3786 #endif
3787 if (GV.OperandSize >= 32) {
3788 if (!Security(5, pMyDisasm)) return;
3789 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3790 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3791 if (MyAddress >= W64LIT (0x100000000)) {
3792 #ifndef BEA_LIGHT_DISASSEMBLY
3793 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3794 #endif
3795 }
3796 else {
3797 #ifndef BEA_LIGHT_DISASSEMBLY
3798 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3799 #endif
3800 }
3801 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3802 (*pMyDisasm).Argument1.AccessMode = READ;
3803 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3804 GV.EIP_+=5;
3805 FillFlags(pMyDisasm,117);
3806 }
3807 else {
3808 if (!Security(3, pMyDisasm)) return;
3809 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3810 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3811 MyAddress = MyAddress & 0xffff;
3812 #ifndef BEA_LIGHT_DISASSEMBLY
3813 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3814 #endif
3815 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3816 (*pMyDisasm).Argument1.AccessMode = READ;
3817 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3818 GV.EIP_+=3;
3819 FillFlags(pMyDisasm,117);
3820 }
3821}
3822
3823/* =======================================
3824 * 0f83h
3825 * ======================================= */
3826void __bea_callspec__ jnc_near(PDISASM pMyDisasm)
3827{
3828 UInt64 MyAddress;
3829 long MyNumber;
3830 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3831 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3832 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3833 }
3834 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3835 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3836 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3837 }
3838 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3839 (*pMyDisasm).Instruction.BranchType = JNC;
3840 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3841 #ifndef BEA_LIGHT_DISASSEMBLY
3842 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnc ");
3843 #endif
3844 if (GV.OperandSize >= 32) {
3845 if (!Security(5, pMyDisasm)) return;
3846 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3847 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3848 if (MyAddress >= W64LIT (0x100000000)) {
3849 #ifndef BEA_LIGHT_DISASSEMBLY
3850 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3851 #endif
3852 }
3853 else {
3854 #ifndef BEA_LIGHT_DISASSEMBLY
3855 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3856 #endif
3857 }
3858 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3859 (*pMyDisasm).Argument1.AccessMode = READ;
3860 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3861 GV.EIP_+=5;
3862 FillFlags(pMyDisasm,117);
3863 }
3864 else {
3865 if (!Security(3, pMyDisasm)) return;
3866 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3867 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3868 MyAddress = MyAddress & 0xffff;
3869 #ifndef BEA_LIGHT_DISASSEMBLY
3870 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3871 #endif
3872 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3873 (*pMyDisasm).Argument1.AccessMode = READ;
3874 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3875 GV.EIP_+=3;
3876 FillFlags(pMyDisasm,117);
3877 }
3878}
3879
3880/* =======================================
3881 * 0f84h
3882 * ======================================= */
3883void __bea_callspec__ je_near(PDISASM pMyDisasm)
3884{
3885 UInt64 MyAddress;
3886 long MyNumber;
3887 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3888 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3889 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3890 }
3891 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3892 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3893 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3894 }
3895 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3896 (*pMyDisasm).Instruction.BranchType = JE;
3897 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3898 #ifndef BEA_LIGHT_DISASSEMBLY
3899 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "je ");
3900 #endif
3901 if (GV.OperandSize >= 32) {
3902 if (!Security(5, pMyDisasm)) return;
3903 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3904 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3905 if (MyAddress >= W64LIT (0x100000000)) {
3906 #ifndef BEA_LIGHT_DISASSEMBLY
3907 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3908 #endif
3909 }
3910 else {
3911 #ifndef BEA_LIGHT_DISASSEMBLY
3912 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3913 #endif
3914 }
3915 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3916 (*pMyDisasm).Argument1.AccessMode = READ;
3917 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3918 GV.EIP_+=5;
3919 FillFlags(pMyDisasm,118);
3920 }
3921 else {
3922 if (!Security(3, pMyDisasm)) return;
3923 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3924 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3925 MyAddress = MyAddress & 0xffff;
3926 #ifndef BEA_LIGHT_DISASSEMBLY
3927 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3928 #endif
3929 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3930 (*pMyDisasm).Argument1.AccessMode = READ;
3931 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3932 GV.EIP_+=3;
3933 FillFlags(pMyDisasm,49);
3934 }
3935}
3936
3937/* =======================================
3938 * 0f85h
3939 * ======================================= */
3940void __bea_callspec__ jne_near(PDISASM pMyDisasm)
3941{
3942 UInt64 MyAddress;
3943 long MyNumber;
3944 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
3945 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
3946 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
3947 }
3948 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
3949 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
3950 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
3951 }
3952 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
3953 (*pMyDisasm).Instruction.BranchType = JNE;
3954 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
3955 #ifndef BEA_LIGHT_DISASSEMBLY
3956 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jne ");
3957 #endif
3958 if (GV.OperandSize >= 32) {
3959 if (!Security(5, pMyDisasm)) return;
3960 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
3961 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
3962 if (MyAddress >= W64LIT (0x100000000)) {
3963 #ifndef BEA_LIGHT_DISASSEMBLY
3964 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
3965 #endif
3966 }
3967 else {
3968 #ifndef BEA_LIGHT_DISASSEMBLY
3969 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
3970 #endif
3971 }
3972 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3973 (*pMyDisasm).Argument1.AccessMode = READ;
3974 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3975 GV.EIP_+=5;
3976 FillFlags(pMyDisasm,49);
3977 }
3978 else {
3979 if (!Security(3, pMyDisasm)) return;
3980 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
3981 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
3982 MyAddress = MyAddress & 0xffff;
3983 #ifndef BEA_LIGHT_DISASSEMBLY
3984 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
3985 #endif
3986 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
3987 (*pMyDisasm).Argument1.AccessMode = READ;
3988 (*pMyDisasm).Instruction.AddrValue = MyAddress;
3989 GV.EIP_+=3;
3990 FillFlags(pMyDisasm,49);
3991 }
3992}
3993/* =======================================
3994 * 0f86h
3995 * ======================================= */
3996void __bea_callspec__ jbe_near(PDISASM pMyDisasm)
3997{
3998 UInt64 MyAddress;
3999 long MyNumber;
4000 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4001 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4002 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4003 }
4004 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4005 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4006 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4007 }
4008 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4009 (*pMyDisasm).Instruction.BranchType = JNA;
4010 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4011 #ifndef BEA_LIGHT_DISASSEMBLY
4012 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jbe ");
4013 #endif
4014 if (GV.OperandSize >= 32) {
4015 if (!Security(5, pMyDisasm)) return;
4016 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4017 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4018 if (MyAddress >= W64LIT (0x100000000)) {
4019 #ifndef BEA_LIGHT_DISASSEMBLY
4020 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4021 #endif
4022 }
4023 else {
4024 #ifndef BEA_LIGHT_DISASSEMBLY
4025 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4026 #endif
4027 }
4028 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4029 (*pMyDisasm).Argument1.AccessMode = READ;
4030 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4031 GV.EIP_+=5;
4032 FillFlags(pMyDisasm,49);
4033 }
4034 else {
4035 if (!Security(3, pMyDisasm)) return;
4036 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4037 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4038 MyAddress = MyAddress & 0xffff;
4039 #ifndef BEA_LIGHT_DISASSEMBLY
4040 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4041 #endif
4042 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4043 (*pMyDisasm).Argument1.AccessMode = READ;
4044 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4045 GV.EIP_+=3;
4046 FillFlags(pMyDisasm,49);
4047 }
4048}
4049
4050
4051/* =======================================
4052 * 0f87h
4053 * ======================================= */
4054void __bea_callspec__ ja_near(PDISASM pMyDisasm)
4055{
4056 UInt64 MyAddress;
4057 long MyNumber;
4058 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4059 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4060 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4061 }
4062 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4063 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4064 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4065 }
4066 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4067 (*pMyDisasm).Instruction.BranchType = JA;
4068 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4069 #ifndef BEA_LIGHT_DISASSEMBLY
4070 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ja ");
4071 #endif
4072 if (GV.OperandSize >= 32) {
4073 if (!Security(5, pMyDisasm)) return;
4074 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4075 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4076 if (MyAddress >= W64LIT (0x100000000)) {
4077 #ifndef BEA_LIGHT_DISASSEMBLY
4078 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4079 #endif
4080 }
4081 else {
4082 #ifndef BEA_LIGHT_DISASSEMBLY
4083 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4084 #endif
4085 }
4086 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4087 (*pMyDisasm).Argument1.AccessMode = READ;
4088 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4089 GV.EIP_+=5;
4090 FillFlags(pMyDisasm,119);
4091 }
4092 else {
4093 if (!Security(3, pMyDisasm)) return;
4094 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4095 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4096 MyAddress = MyAddress & 0xffff;
4097 #ifndef BEA_LIGHT_DISASSEMBLY
4098 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4099 #endif
4100 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4101 (*pMyDisasm).Argument1.AccessMode = READ;
4102 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4103 GV.EIP_+=3;
4104 FillFlags(pMyDisasm,119);
4105 }
4106}
4107
4108/* =======================================
4109 * 0f88h
4110 * ======================================= */
4111void __bea_callspec__ js_near(PDISASM pMyDisasm)
4112{
4113 UInt64 MyAddress;
4114 long MyNumber;
4115 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4116 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4117 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4118 }
4119 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4120 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4121 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4122 }
4123 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4124 (*pMyDisasm).Instruction.BranchType = JS;
4125 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4126 #ifndef BEA_LIGHT_DISASSEMBLY
4127 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "js ");
4128 #endif
4129 if (GV.OperandSize >= 32) {
4130 if (!Security(5, pMyDisasm)) return;
4131 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4132 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4133 if (MyAddress >= W64LIT (0x100000000)) {
4134 #ifndef BEA_LIGHT_DISASSEMBLY
4135 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4136 #endif
4137 }
4138 else {
4139 #ifndef BEA_LIGHT_DISASSEMBLY
4140 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4141 #endif
4142 }
4143 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4144 (*pMyDisasm).Argument1.AccessMode = READ;
4145 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4146 GV.EIP_+=5;
4147 FillFlags(pMyDisasm,120);
4148 }
4149 else {
4150 if (!Security(3, pMyDisasm)) return;
4151 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4152 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4153 MyAddress = MyAddress & 0xffff;
4154 #ifndef BEA_LIGHT_DISASSEMBLY
4155 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4156 #endif
4157 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4158 (*pMyDisasm).Argument1.AccessMode = READ;
4159 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4160 GV.EIP_+=3;
4161 FillFlags(pMyDisasm,49);
4162 }
4163}
4164
4165/* =======================================
4166 * 0f89h
4167 * ======================================= */
4168void __bea_callspec__ jns_near(PDISASM pMyDisasm)
4169{
4170 UInt64 MyAddress;
4171 long MyNumber;
4172 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4173 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4174 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4175 }
4176 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4177 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4178 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4179 }
4180 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4181 (*pMyDisasm).Instruction.BranchType = JNS;
4182 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4183 #ifndef BEA_LIGHT_DISASSEMBLY
4184 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jns ");
4185 #endif
4186 if (GV.OperandSize >= 32) {
4187 if (!Security(5, pMyDisasm)) return;
4188 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4189 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4190 if (MyAddress >= W64LIT (0x100000000)) {
4191 #ifndef BEA_LIGHT_DISASSEMBLY
4192 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4193 #endif
4194 }
4195 else {
4196 #ifndef BEA_LIGHT_DISASSEMBLY
4197 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4198 #endif
4199 }
4200 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4201 (*pMyDisasm).Argument1.AccessMode = READ;
4202 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4203 GV.EIP_+=5;
4204 FillFlags(pMyDisasm,120);
4205 }
4206 else {
4207 if (!Security(3, pMyDisasm)) return;
4208 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4209 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4210 MyAddress = MyAddress & 0xffff;
4211 #ifndef BEA_LIGHT_DISASSEMBLY
4212 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4213 #endif
4214 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4215 (*pMyDisasm).Argument1.AccessMode = READ;
4216 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4217 GV.EIP_+=3;
4218 FillFlags(pMyDisasm,49);
4219 }
4220}
4221
4222/* =======================================
4223 * 0f8ah
4224 * ======================================= */
4225void __bea_callspec__ jp_near(PDISASM pMyDisasm)
4226{
4227 UInt64 MyAddress;
4228 long MyNumber;
4229 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4230 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4231 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4232 }
4233 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4234 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4235 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4236 }
4237 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4238 (*pMyDisasm).Instruction.BranchType = JP;
4239 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4240 #ifndef BEA_LIGHT_DISASSEMBLY
4241 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jp ");
4242 #endif
4243 if (GV.OperandSize >= 32) {
4244 if (!Security(5, pMyDisasm)) return;
4245 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4246 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4247 if (MyAddress >= W64LIT (0x100000000)) {
4248 #ifndef BEA_LIGHT_DISASSEMBLY
4249 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4250 #endif
4251 }
4252 else {
4253 #ifndef BEA_LIGHT_DISASSEMBLY
4254 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4255 #endif
4256 }
4257 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4258 (*pMyDisasm).Argument1.AccessMode = READ;
4259 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4260 GV.EIP_+=5;
4261 FillFlags(pMyDisasm,121);
4262 }
4263 else {
4264 if (!Security(3, pMyDisasm)) return;
4265 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4266 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4267 MyAddress = MyAddress & 0xffff;
4268 #ifndef BEA_LIGHT_DISASSEMBLY
4269 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4270 #endif
4271 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4272 (*pMyDisasm).Argument1.AccessMode = READ;
4273 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4274 GV.EIP_+=3;
4275 FillFlags(pMyDisasm,49);
4276 }
4277}
4278
4279/* =======================================
4280 * 0f8bh
4281 * ======================================= */
4282void __bea_callspec__ jnp_near(PDISASM pMyDisasm)
4283{
4284 UInt64 MyAddress;
4285 long MyNumber;
4286 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4287 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4288 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4289 }
4290 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4291 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4292 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4293 }
4294 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4295 (*pMyDisasm).Instruction.BranchType = JNP;
4296 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4297 #ifndef BEA_LIGHT_DISASSEMBLY
4298 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnp ");
4299 #endif
4300 if (GV.OperandSize >= 32) {
4301 if (!Security(5, pMyDisasm)) return;
4302 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4303 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4304 if (MyAddress >= W64LIT (0x100000000)) {
4305 #ifndef BEA_LIGHT_DISASSEMBLY
4306 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4307 #endif
4308 }
4309 else {
4310 #ifndef BEA_LIGHT_DISASSEMBLY
4311 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4312 #endif
4313 }
4314 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4315 (*pMyDisasm).Argument1.AccessMode = READ;
4316 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4317 GV.EIP_+=5;
4318 FillFlags(pMyDisasm,121);
4319 }
4320 else {
4321 if (!Security(3, pMyDisasm)) return;
4322 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4323 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4324 MyAddress = MyAddress & 0xffff;
4325 #ifndef BEA_LIGHT_DISASSEMBLY
4326 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4327 #endif
4328 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4329 (*pMyDisasm).Argument1.AccessMode = READ;
4330 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4331 GV.EIP_+=3;
4332 FillFlags(pMyDisasm,121);
4333 }
4334}
4335
4336/* =======================================
4337 * 0f8ch
4338 * ======================================= */
4339void __bea_callspec__ jl_near(PDISASM pMyDisasm)
4340{
4341 UInt64 MyAddress;
4342 long MyNumber;
4343 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4344 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4345 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4346 }
4347 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4348 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4349 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4350 }
4351 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4352 (*pMyDisasm).Instruction.BranchType = JL;
4353 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4354 #ifndef BEA_LIGHT_DISASSEMBLY
4355 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jl ");
4356 #endif
4357 if (GV.OperandSize >= 32) {
4358 if (!Security(5, pMyDisasm)) return;
4359 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4360 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4361 if (MyAddress >= W64LIT (0x100000000)) {
4362 #ifndef BEA_LIGHT_DISASSEMBLY
4363 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4364 #endif
4365 }
4366 else {
4367 #ifndef BEA_LIGHT_DISASSEMBLY
4368 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4369 #endif
4370 }
4371 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4372 (*pMyDisasm).Argument1.AccessMode = READ;
4373 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4374 GV.EIP_+=5;
4375 FillFlags(pMyDisasm,122);
4376 }
4377 else {
4378 if (!Security(3, pMyDisasm)) return;
4379 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4380 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4381 MyAddress = MyAddress & 0xffff;
4382 #ifndef BEA_LIGHT_DISASSEMBLY
4383 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4384 #endif
4385 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4386 (*pMyDisasm).Argument1.AccessMode = READ;
4387 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4388 GV.EIP_+=3;
4389 FillFlags(pMyDisasm,122);
4390 }
4391}
4392
4393/* =======================================
4394 * 0f8dh
4395 * ======================================= */
4396void __bea_callspec__ jnl_near(PDISASM pMyDisasm)
4397{
4398 UInt64 MyAddress;
4399 long MyNumber;
4400 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4401 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4402 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4403 }
4404 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4405 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4406 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4407 }
4408 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4409 (*pMyDisasm).Instruction.BranchType = JNL;
4410 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4411 #ifndef BEA_LIGHT_DISASSEMBLY
4412 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jnl ");
4413 #endif
4414 if (GV.OperandSize >= 32) {
4415 if (!Security(5, pMyDisasm)) return;
4416 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4417 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4418 if (MyAddress >= W64LIT (0x100000000)) {
4419 #ifndef BEA_LIGHT_DISASSEMBLY
4420 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4421 #endif
4422 }
4423 else {
4424 #ifndef BEA_LIGHT_DISASSEMBLY
4425 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4426 #endif
4427 }
4428 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4429 (*pMyDisasm).Argument1.AccessMode = READ;
4430 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4431 GV.EIP_+=5;
4432 FillFlags(pMyDisasm,122);
4433 }
4434 else {
4435 if (!Security(3, pMyDisasm)) return;
4436 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4437 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4438 MyAddress = MyAddress & 0xffff;
4439 #ifndef BEA_LIGHT_DISASSEMBLY
4440 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4441 #endif
4442 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4443 (*pMyDisasm).Argument1.AccessMode = READ;
4444 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4445 GV.EIP_+=3;
4446 FillFlags(pMyDisasm,122);
4447 }
4448}
4449
4450/* =======================================
4451 * 0f8eh
4452 * ======================================= */
4453void __bea_callspec__ jle_near(PDISASM pMyDisasm)
4454{
4455 UInt64 MyAddress;
4456 Int32 MyNumber;
4457 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4458 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4459 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4460 }
4461 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4462 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4463 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4464 }
4465 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4466 (*pMyDisasm).Instruction.BranchType = JNG;
4467 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4468 #ifndef BEA_LIGHT_DISASSEMBLY
4469 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jng ");
4470 #endif
4471 if (GV.OperandSize >= 32) {
4472 if (!Security(5, pMyDisasm)) return;
4473 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4474 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4475 if (MyAddress >= W64LIT (0x100000000)) {
4476 #ifndef BEA_LIGHT_DISASSEMBLY
4477 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4478 #endif
4479 }
4480 else {
4481 #ifndef BEA_LIGHT_DISASSEMBLY
4482 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4483 #endif
4484 }
4485 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4486 (*pMyDisasm).Argument1.AccessMode = READ;
4487 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4488 GV.EIP_+=5;
4489 FillFlags(pMyDisasm,115);
4490 }
4491 else {
4492 if (!Security(3, pMyDisasm)) return;
4493 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4494 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4495 MyAddress = MyAddress & 0xffff;
4496 #ifndef BEA_LIGHT_DISASSEMBLY
4497 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4498 #endif
4499 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4500 (*pMyDisasm).Argument1.AccessMode = READ;
4501 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4502 GV.EIP_+=3;
4503 FillFlags(pMyDisasm,115);
4504 }
4505}
4506
4507/* =======================================
4508 * 0f8fh
4509 * ======================================= */
4510void __bea_callspec__ jnle_near(PDISASM pMyDisasm)
4511{
4512 UInt64 MyAddress;
4513 Int64 MyNumber;
4514 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4515 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4516 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4517 }
4518 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4519 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4520 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4521 }
4522 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4523 (*pMyDisasm).Instruction.BranchType = JG;
4524 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4525 #ifndef BEA_LIGHT_DISASSEMBLY
4526 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jg ");
4527 #endif
4528 if (GV.OperandSize >= 32) {
4529 if (!Security(5, pMyDisasm)) return;
4530 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4531 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+6+MyNumber, pMyDisasm);
4532 if (MyAddress >= W64LIT (0x100000000)) {
4533 #ifndef BEA_LIGHT_DISASSEMBLY
4534 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4535 #endif
4536 }
4537 else {
4538 #ifndef BEA_LIGHT_DISASSEMBLY
4539 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4540 #endif
4541 }
4542 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4543 (*pMyDisasm).Argument1.AccessMode = READ;
4544 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4545 GV.EIP_+=5;
4546 FillFlags(pMyDisasm,115);
4547 }
4548 else {
4549 if (!Security(3, pMyDisasm)) return;
4550 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4551 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+4+MyNumber, pMyDisasm);
4552 MyAddress = MyAddress & 0xffff;
4553 #ifndef BEA_LIGHT_DISASSEMBLY
4554 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4555 #endif
4556 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4557 (*pMyDisasm).Argument1.AccessMode = READ;
4558 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4559 GV.EIP_+=3;
4560 FillFlags(pMyDisasm,115);
4561 }
4562}
4563
4564/* =======================================
4565 * 0e3h
4566 * ======================================= */
4567void __bea_callspec__ jecxz_(PDISASM pMyDisasm)
4568{
4569 UInt64 MyAddress;
4570 Int64 MyNumber;
4571 if ((*pMyDisasm).Prefix.CSPrefix == InUsePrefix) {
4572 (*pMyDisasm).Prefix.CSPrefix = NotUsedPrefix;
4573 (*pMyDisasm).Prefix.BranchNotTaken = InUsePrefix;
4574 }
4575 if ((*pMyDisasm).Prefix.DSPrefix == InUsePrefix) {
4576 (*pMyDisasm).Prefix.DSPrefix = NotUsedPrefix;
4577 (*pMyDisasm).Prefix.BranchTaken = InUsePrefix;
4578 }
4579 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4580 (*pMyDisasm).Instruction.BranchType = JECXZ;
4581 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4582 if (GV.AddressSize == 64) {
4583 #ifndef BEA_LIGHT_DISASSEMBLY
4584 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jrcxz ");
4585 #endif
4586 }
4587 else if (GV.AddressSize == 32) {
4588 #ifndef BEA_LIGHT_DISASSEMBLY
4589 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jecxz ");
4590 #endif
4591 }
4592 else {
4593 #ifndef BEA_LIGHT_DISASSEMBLY
4594 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jcxz ");
4595 #endif
4596 }
4597 if (GV.OperandSize >= 32) {
4598 if (!Security(5, pMyDisasm)) return;
4599 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
4600 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
4601 if (MyAddress >= W64LIT (0x100000000)) {
4602 #ifndef BEA_LIGHT_DISASSEMBLY
4603 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4604 #endif
4605 }
4606 else {
4607 #ifndef BEA_LIGHT_DISASSEMBLY
4608 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4609 #endif
4610 }
4611 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4612 (*pMyDisasm).Argument1.AccessMode = READ;
4613 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4614 GV.EIP_+=2;
4615 FillFlags(pMyDisasm,49);
4616 }
4617 else {
4618 if (!Security(3, pMyDisasm)) return;
4619 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
4620 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
4621 MyAddress = MyAddress & 0xffff;
4622 #ifndef BEA_LIGHT_DISASSEMBLY
4623 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4624 #endif
4625 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4626 (*pMyDisasm).Argument1.AccessMode = READ;
4627 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4628 GV.EIP_+=2;
4629 FillFlags(pMyDisasm,49);
4630 }
4631}
4632
4633/* =======================================
4634 * 0e9h
4635 * ======================================= */
4636void __bea_callspec__ jmp_near(PDISASM pMyDisasm)
4637{
4638 UInt64 MyAddress;
4639 long MyNumber;
4640 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4641 (*pMyDisasm).Instruction.BranchType = JmpType;
4642 (*pMyDisasm).Argument1.AccessMode = READ;
4643 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4644 #ifndef BEA_LIGHT_DISASSEMBLY
4645 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jmp ");
4646 #endif
4647 if (GV.OperandSize >= 32) {
4648 if (!Security(5, pMyDisasm)) return;
4649 MyNumber = *((Int32*)(UIntPtr) (GV.EIP_+1));
4650 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+5+MyNumber, pMyDisasm);
4651 if (MyAddress >= W64LIT (0x100000000)) {
4652 #ifndef BEA_LIGHT_DISASSEMBLY
4653 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4654 #endif
4655 }
4656 else {
4657 #ifndef BEA_LIGHT_DISASSEMBLY
4658 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4659 #endif
4660 }
4661 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4662
4663 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4664 GV.EIP_+=5;
4665 FillFlags(pMyDisasm,51);
4666 }
4667 else {
4668 if (!Security(3, pMyDisasm)) return;
4669 MyNumber = *((Int16*)(UIntPtr) (GV.EIP_+1));
4670 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+3+MyNumber, pMyDisasm);
4671 MyAddress = MyAddress & 0xffff;
4672 #ifndef BEA_LIGHT_DISASSEMBLY
4673 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
4674 #endif
4675 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4676 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4677 GV.EIP_+=3;
4678 FillFlags(pMyDisasm,51);
4679 }
4680}
4681
4682
4683/* =======================================
4684 * 0ebh
4685 * ======================================= */
4686void __bea_callspec__ jmp_short(PDISASM pMyDisasm)
4687{
4688 UInt64 MyAddress = 0;
4689 signed long MyNumber = 0;
4690 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4691 (*pMyDisasm).Instruction.BranchType = JmpType;
4692 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
4693 #ifndef BEA_LIGHT_DISASSEMBLY
4694 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jmp ");
4695 #endif
4696 if (!Security(1, pMyDisasm)) return;
4697 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
4698 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
4699 if (GV.OperandSize == 16) MyAddress = MyAddress & 0xffff;
4700 if (MyAddress >= W64LIT (0x100000000)) {
4701 #ifndef BEA_LIGHT_DISASSEMBLY
4702 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
4703 #endif
4704 }
4705 else {
4706 #ifndef BEA_LIGHT_DISASSEMBLY
4707 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
4708 #endif
4709 }
4710 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
4711 (*pMyDisasm).Argument1.AccessMode = READ;
4712 (*pMyDisasm).Instruction.AddrValue = MyAddress;
4713 GV.EIP_+=2;
4714 FillFlags(pMyDisasm,49);
4715}
4716
4717
4718/* =======================================
4719 *
4720 * ======================================= */
4721void __bea_callspec__ jmp_far(PDISASM pMyDisasm)
4722{
4723 UInt32 MyNumber;
4724 UInt64 MyAddress;
4725 size_t i = 0;
4726 if (GV.Architecture == 64) {
4727 FailDecode(pMyDisasm);
4728 }
4729 else {
4730 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4731 (*pMyDisasm).Instruction.BranchType = JmpType;
4732 (*pMyDisasm).Argument1.AccessMode = READ;
4733 if (GV.SYNTAX_ == ATSyntax) {
4734 #ifndef BEA_LIGHT_DISASSEMBLY
4735 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ljmp ");
4736 #endif
4737 #ifndef BEA_LIGHT_DISASSEMBLY
4738 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic,"\x24");
4739 #endif
4740 i++;
4741 }
4742 else {
4743 #ifndef BEA_LIGHT_DISASSEMBLY
4744 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "jmp far ");
4745 #endif
4746 }
4747 if (GV.OperandSize ==32) {
4748 if (!Security(7, pMyDisasm)) return;
4749 MyNumber = *((UInt16*)(UIntPtr) (GV.EIP_+5));
4750 #ifndef BEA_LIGHT_DISASSEMBLY
4751 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.4X",(Int64) MyNumber);
4752 #endif
4753 }
4754 else {
4755 if (!Security(5, pMyDisasm)) return;
4756 MyNumber = *((UInt16*)(UIntPtr) (GV.EIP_+3));
4757 #ifndef BEA_LIGHT_DISASSEMBLY
4758 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.4X",(Int64) MyNumber);
4759 #endif
4760 }
4761 if (GV.SYNTAX_ == ATSyntax) {
4762 #ifndef BEA_LIGHT_DISASSEMBLY
4763 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic+i, " , \x24");
4764 #endif
4765 i+=4;
4766 }
4767 else {
4768 #ifndef BEA_LIGHT_DISASSEMBLY
4769 (void) strcpy ((*pMyDisasm).Argument1.ArgMnemonic+i, " : ");
4770 #endif
4771 i+=3;
4772 }
4773 MyAddress = MyNumber*16;
4774 MyNumber = *((UInt32*)(UIntPtr) (GV.EIP_+1));
4775 if (GV.OperandSize == 16) {
4776 MyNumber = MyNumber & 0xffff;
4777 }
4778 #ifndef BEA_LIGHT_DISASSEMBLY
4779 i += CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument1.ArgMnemonic+i, "%.8X",(Int64) MyNumber);
4780 #endif
4781 if (GV.OperandSize == 32) {
4782 GV.EIP_+=7;
4783 }
4784 else {
4785 GV.EIP_+=5;
4786 }
4787 (*pMyDisasm).Instruction.AddrValue = MyAddress + MyNumber;
4788 FillFlags(pMyDisasm,51);
4789 }
4790}
4791
4792/* =======================================
4793 *
4794 * ======================================= */
4795void __bea_callspec__ lahf_(PDISASM pMyDisasm)
4796{
4797 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+FLAG_CONTROL_INSTRUCTION;
4798 #ifndef BEA_LIGHT_DISASSEMBLY
4799 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lahf ");
4800 #endif
4801 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
4802 (*pMyDisasm).Argument1.ArgSize = 8;
4803 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG0;
4804 (*pMyDisasm).Argument2.ArgSize = 8;
4805 GV.EIP_++;
4806}
4807
4808/* =======================================
4809 *
4810 * ======================================= */
4811void __bea_callspec__ lar_GvEw(PDISASM pMyDisasm)
4812{
4813 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
4814 #ifndef BEA_LIGHT_DISASSEMBLY
4815 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lar ");
4816 #endif
4817 GvEw(pMyDisasm);
4818 FillFlags(pMyDisasm, 53);
4819}
4820
4821/* =======================================
4822 *
4823 * ======================================= */
4824void __bea_callspec__ lds_GvM(PDISASM pMyDisasm)
4825{
4826 /* if MOD == 11b, invalid instruction */
4827 /* or VEX Prefix - implemented in next release (AVX) */
4828
4829 if (GV.Architecture == 64) {
4830 FailDecode(pMyDisasm);
4831 }
4832 else {
4833 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
4834 #ifndef BEA_LIGHT_DISASSEMBLY
4835 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lds ");
4836 #endif
4837 if (GV.OperandSize == 32) {
4838 GV.MemDecoration = Arg2fword;
4839 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4840 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4841 GV.EIP_+= GV.DECALAGE_EIP+2;
4842 }
4843 else {
4844 GV.MemDecoration = Arg2dword;
4845 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4846 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4847 GV.EIP_+= GV.DECALAGE_EIP+2;
4848 }
4849 }
4850}
4851
4852/* =======================================
4853 * 0c9h
4854 * ======================================= */
4855void __bea_callspec__ leave_(PDISASM pMyDisasm)
4856{
4857 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
4858 #ifndef BEA_LIGHT_DISASSEMBLY
4859 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "leave ");
4860 #endif
4861 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG4;
4862 (*pMyDisasm).Argument1.ArgSize = 32;
4863 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+SPECIAL_REG+REG5;
4864 (*pMyDisasm).Argument2.ArgSize = 32;
4865 GV.EIP_++;
4866}
4867
4868/* =======================================
4869 *
4870 * ======================================= */
4871void __bea_callspec__ lea_GvM(PDISASM pMyDisasm)
4872{
4873
4874 /* if MOD == 11b, invalid instruction */
4875 /* or VEX Prefix - implemented in next release (AVX) */
4876
4877 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+MISCELLANEOUS_INSTRUCTION;
4878 #ifndef BEA_LIGHT_DISASSEMBLY
4879 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lea ");
4880 #endif
4881 if (GV.OperandSize >= 32) {
4882 if (GV.OperandSize == 64) {
4883 GV.MemDecoration = Arg2qword;
4884 }
4885 else {
4886 GV.MemDecoration = Arg2dword;
4887 }
4888 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4889 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4890 GV.EIP_+= GV.DECALAGE_EIP+2;
4891 }
4892 else {
4893 GV.MemDecoration = Arg2word;
4894 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4895 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4896 GV.EIP_+= GV.DECALAGE_EIP+2;
4897 }
4898 (*pMyDisasm).Argument2.AccessMode = 0;
4899}
4900
4901/* =======================================
4902 *
4903 * ======================================= */
4904void __bea_callspec__ les_GvM(PDISASM pMyDisasm)
4905{
4906
4907 if (GV.Architecture == 64) {
4908 FailDecode(pMyDisasm);
4909 }
4910 else {
4911 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
4912 #ifndef BEA_LIGHT_DISASSEMBLY
4913 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "les ");
4914 #endif
4915 if (GV.OperandSize == 32) {
4916 GV.MemDecoration = Arg2fword;
4917 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4918 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4919 GV.EIP_+= GV.DECALAGE_EIP+2;
4920 }
4921 else {
4922 GV.MemDecoration = Arg2dword;
4923 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
4924 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
4925 GV.EIP_+= GV.DECALAGE_EIP+2;
4926 }
4927 }
4928}
4929
4930/* =======================================
4931 * 0ach
4932 * ======================================= */
4933void __bea_callspec__ lodsb_(PDISASM pMyDisasm)
4934{
4935 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
4936 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
4937 }
4938 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
4939 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
4940 }
4941 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
4942 #ifndef BEA_LIGHT_DISASSEMBLY
4943 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsb ");
4944 #endif
4945 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
4946 (*pMyDisasm).Argument1.ArgSize = 8;
4947 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
4948 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
4949 (*pMyDisasm).Argument2.ArgSize = 8;
4950 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
4951 GV.EIP_++;
4952 FillFlags(pMyDisasm, 59);
4953}
4954
4955/* =======================================
4956 * 0adh
4957 * ======================================= */
4958void __bea_callspec__ lodsw_(PDISASM pMyDisasm)
4959{
4960 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
4961 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
4962 }
4963 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
4964 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
4965 }
4966 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
4967 if (GV.OperandSize == 64) {
4968 #ifndef BEA_LIGHT_DISASSEMBLY
4969 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsq ");
4970 #endif
4971 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
4972 (*pMyDisasm).Argument1.ArgSize = 64;
4973 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
4974 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
4975 (*pMyDisasm).Argument2.ArgSize = 64;
4976 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
4977 GV.EIP_++;
4978 FillFlags(pMyDisasm, 59);
4979 }
4980 else if (GV.OperandSize == 32) {
4981 #ifndef BEA_LIGHT_DISASSEMBLY
4982 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsd ");
4983 #endif
4984 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
4985 (*pMyDisasm).Argument1.ArgSize = 32;
4986 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
4987 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
4988 (*pMyDisasm).Argument2.ArgSize = 32;
4989 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
4990 GV.EIP_++;
4991 FillFlags(pMyDisasm, 59);
4992 }
4993 else {
4994 #ifndef BEA_LIGHT_DISASSEMBLY
4995 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lodsw ");
4996 #endif
4997 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
4998 (*pMyDisasm).Argument1.ArgSize = 16;
4999 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
5000 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
5001 (*pMyDisasm).Argument2.ArgSize = 16;
5002 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6;
5003 GV.EIP_++;
5004 FillFlags(pMyDisasm, 59);
5005 }
5006}
5007
5008/* =======================================
5009 * 0e2h
5010 * ======================================= */
5011void __bea_callspec__ loop_(PDISASM pMyDisasm)
5012{
5013 signed long MyNumber;
5014 UInt64 MyAddress;
5015 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
5016 (*pMyDisasm).Instruction.BranchType = JE;
5017 #ifndef BEA_LIGHT_DISASSEMBLY
5018 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "loop ");
5019 #endif
5020 if (!Security(1, pMyDisasm)) return;
5021 if (GV.OperandSize >= 32) {
5022 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5023 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5024 if (MyAddress >= W64LIT (0x100000000)) {
5025 #ifndef BEA_LIGHT_DISASSEMBLY
5026 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5027 #endif
5028 }
5029 else {
5030 #ifndef BEA_LIGHT_DISASSEMBLY
5031 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
5032 #endif
5033 }
5034 (*pMyDisasm).Argument1.AccessMode = READ;
5035 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5036 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5037 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5038 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5039 GV.EIP_+=2;
5040 FillFlags(pMyDisasm, 60);
5041 }
5042 else {
5043 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5044 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5045 MyAddress = MyAddress & 0xffff;
5046 #ifndef BEA_LIGHT_DISASSEMBLY
5047 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
5048 #endif
5049 (*pMyDisasm).Argument1.AccessMode = READ;
5050 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5051 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5052 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5053 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5054 GV.EIP_+=2;
5055 FillFlags(pMyDisasm, 60);
5056 }
5057}
5058
5059/* =======================================
5060 * 0xe0
5061 * ======================================= */
5062void __bea_callspec__ loopne_(PDISASM pMyDisasm)
5063{
5064 signed long MyNumber;
5065 UInt64 MyAddress;
5066 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
5067 (*pMyDisasm).Instruction.BranchType = JNE;
5068 #ifndef BEA_LIGHT_DISASSEMBLY
5069 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "loopne ");
5070 #endif
5071 if (!Security(1, pMyDisasm)) return;
5072 if (GV.OperandSize >= 32) {
5073 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5074 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5075 if (MyAddress >= W64LIT (0x100000000)) {
5076 #ifndef BEA_LIGHT_DISASSEMBLY
5077 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5078 #endif
5079 }
5080 else {
5081 #ifndef BEA_LIGHT_DISASSEMBLY
5082 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
5083 #endif
5084 }
5085 (*pMyDisasm).Argument1.AccessMode = READ;
5086 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5087 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5088 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5089 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5090 GV.EIP_+=2;
5091 FillFlags(pMyDisasm, 61);
5092 }
5093 else {
5094 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5095 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5096 MyAddress = MyAddress & 0xffff;
5097 #ifndef BEA_LIGHT_DISASSEMBLY
5098 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
5099 #endif
5100 (*pMyDisasm).Argument1.AccessMode = READ;
5101 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5102 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5103 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5104 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5105 GV.EIP_+=2;
5106 FillFlags(pMyDisasm, 61);
5107
5108 }
5109}
5110
5111/* =======================================
5112 * 0xe1
5113 * ======================================= */
5114void __bea_callspec__ loope_(PDISASM pMyDisasm)
5115{
5116 signed long MyNumber;
5117 UInt64 MyAddress;
5118 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+CONTROL_TRANSFER;
5119 (*pMyDisasm).Instruction.BranchType = JE;
5120 #ifndef BEA_LIGHT_DISASSEMBLY
5121 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "loope ");
5122 #endif
5123 if (!Security(1, pMyDisasm)) return;
5124 if (GV.OperandSize >= 32) {
5125 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5126 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5127 if (MyAddress >= W64LIT (0x100000000)) {
5128 #ifndef BEA_LIGHT_DISASSEMBLY
5129 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5130 #endif
5131 }
5132 else {
5133 #ifndef BEA_LIGHT_DISASSEMBLY
5134 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
5135 #endif
5136 }
5137 (*pMyDisasm).Argument1.AccessMode = READ;
5138 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5139 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5140 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5141 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5142 GV.EIP_+=2;
5143 FillFlags(pMyDisasm, 61);
5144 }
5145 else {
5146 MyNumber = *((Int8*)(UIntPtr) (GV.EIP_+1));
5147 CalculateRelativeAddress(&MyAddress,(Int64) GV.NB_PREFIX+2+MyNumber, pMyDisasm);
5148 MyAddress = MyAddress & 0xffff;
5149 #ifndef BEA_LIGHT_DISASSEMBLY
5150 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
5151 #endif
5152 (*pMyDisasm).Argument1.AccessMode = READ;
5153 (*pMyDisasm).Argument1.ArgSize = GV.OperandSize;
5154 (*pMyDisasm).Argument1.ArgType = CONSTANT_TYPE+RELATIVE_;
5155 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG1;
5156 (*pMyDisasm).Instruction.AddrValue = MyAddress;
5157 GV.EIP_+=2;
5158 FillFlags(pMyDisasm, 61);
5159
5160 }
5161}
5162
5163/* =======================================
5164 *
5165 * ======================================= */
5166void __bea_callspec__ lsl_GvEw(PDISASM pMyDisasm)
5167{
5168 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
5169 #ifndef BEA_LIGHT_DISASSEMBLY
5170 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lsl ");
5171 #endif
5172 GvEw(pMyDisasm);
5173 FillFlags(pMyDisasm, 62);
5174}
5175
5176/* =======================================
5177 *
5178 * ======================================= */
5179void __bea_callspec__ lss_Mp(PDISASM pMyDisasm)
5180{
5181 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
5182 #ifndef BEA_LIGHT_DISASSEMBLY
5183 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lss ");
5184 #endif
5185 GvEv(pMyDisasm);
5186}
5187
5188/* =======================================
5189 *
5190 * ======================================= */
5191void __bea_callspec__ lfs_Mp(PDISASM pMyDisasm)
5192{
5193 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
5194 #ifndef BEA_LIGHT_DISASSEMBLY
5195 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lfs ");
5196 #endif
5197 GvEv(pMyDisasm);
5198}
5199
5200/* =======================================
5201 *
5202 * ======================================= */
5203void __bea_callspec__ lgs_Mp(PDISASM pMyDisasm)
5204{
5205 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+SEGMENT_REGISTER;
5206 #ifndef BEA_LIGHT_DISASSEMBLY
5207 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lgs ");
5208 #endif
5209 GvEv(pMyDisasm);
5210}
5211
5212/* =======================================
5213 *
5214 * ======================================= */
5215void __bea_callspec__ mov_RdCd(PDISASM pMyDisasm)
5216{
5217 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
5218 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
5219 if (GV.MOD_== 3) {
5220 #ifndef BEA_LIGHT_DISASSEMBLY
5221 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5222 #endif
5223 GV.CR_ = 1;
5224 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
5225 GV.CR_ = 0;
5226 FillFlags(pMyDisasm,67);
5227 GV.EIP_ += GV.DECALAGE_EIP+2;
5228 }
5229 else {
5230 FailDecode(pMyDisasm);
5231 }
5232}
5233
5234
5235/* =======================================
5236 *
5237 * ======================================= */
5238void __bea_callspec__ mov_RdDd(PDISASM pMyDisasm)
5239{
5240 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
5241 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
5242 if (GV.MOD_== 3) {
5243 #ifndef BEA_LIGHT_DISASSEMBLY
5244 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5245 #endif
5246 GV.DR_ = 1;
5247 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
5248 GV.DR_ = 0;
5249 FillFlags(pMyDisasm,67);
5250 GV.EIP_ += GV.DECALAGE_EIP+2;
5251 }
5252 else {
5253 FailDecode(pMyDisasm);
5254 }
5255}
5256
5257/* =======================================
5258 *
5259 * ======================================= */
5260void __bea_callspec__ mov_CdRd(PDISASM pMyDisasm)
5261{
5262 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
5263 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
5264 if (GV.MOD_== 3) {
5265 #ifndef BEA_LIGHT_DISASSEMBLY
5266 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5267 #endif
5268 GV.CR_ = 1;
5269 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
5270 GV.CR_ = 0;
5271 FillFlags(pMyDisasm,67);
5272 GV.EIP_ += GV.DECALAGE_EIP+2;
5273 }
5274 else {
5275 FailDecode(pMyDisasm);
5276 }
5277}
5278
5279/* =======================================
5280 *
5281 * ======================================= */
5282void __bea_callspec__ mov_DdRd(PDISASM pMyDisasm)
5283{
5284 (*pMyDisasm).Instruction.Category = SYSTEM_INSTRUCTION;
5285 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
5286 if (GV.MOD_== 3) {
5287 #ifndef BEA_LIGHT_DISASSEMBLY
5288 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5289 #endif
5290 GV.DR_ = 1;
5291 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
5292 GV.DR_ = 0;
5293 FillFlags(pMyDisasm,67);
5294 GV.EIP_ += GV.DECALAGE_EIP+2;
5295 }
5296 else {
5297 FailDecode(pMyDisasm);
5298 }
5299}
5300
5301/* =======================================
5302 * 88h
5303 * ======================================= */
5304void __bea_callspec__ mov_EbGb(PDISASM pMyDisasm)
5305{
5306 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5307 #ifndef BEA_LIGHT_DISASSEMBLY
5308 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5309 #endif
5310 EbGb(pMyDisasm);
5311}
5312
5313/* =======================================
5314 * 89h
5315 * ======================================= */
5316void __bea_callspec__ mov_EvGv(PDISASM pMyDisasm)
5317{
5318 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5319 #ifndef BEA_LIGHT_DISASSEMBLY
5320 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5321 #endif
5322 EvGv(pMyDisasm);
5323}
5324
5325/* =======================================
5326 * 8ah
5327 * ======================================= */
5328void __bea_callspec__ mov_GbEb(PDISASM pMyDisasm)
5329{
5330 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5331 #ifndef BEA_LIGHT_DISASSEMBLY
5332 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5333 #endif
5334 GbEb(pMyDisasm);
5335}
5336
5337/* =======================================
5338 * 8bh
5339 * ======================================= */
5340void __bea_callspec__ mov_GvEv(PDISASM pMyDisasm)
5341{
5342 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5343 #ifndef BEA_LIGHT_DISASSEMBLY
5344 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5345 #endif
5346 GvEv(pMyDisasm);
5347}
5348
5349/* =======================================
5350 * 0a0h
5351 * ======================================= */
5352void __bea_callspec__ mov_ALOb(PDISASM pMyDisasm)
5353{
5354 UInt64 MyAddress;
5355 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5356 #ifndef BEA_LIGHT_DISASSEMBLY
5357 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5358 #endif
5359 GV.MemDecoration = Arg2byte;
5360 GV.RM_ = 5;
5361 GV.MOD_= 0;
5362 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
5363 (*pMyDisasm).Argument1.ArgSize = 8;
5364 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE ;
5365 (*pMyDisasm).Argument2.ArgSize = 8;
5366 if (GV.AddressSize == 64) {
5367 if (!Security(9, pMyDisasm)) return;
5368 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
5369 #ifndef BEA_LIGHT_DISASSEMBLY
5370 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5371 #endif
5372 GV.EIP_+=9;
5373 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5374 }
5375 else if (GV.AddressSize == 32) {
5376 if (!Security(5, pMyDisasm)) return;
5377 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
5378 #ifndef BEA_LIGHT_DISASSEMBLY
5379 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
5380 #endif
5381 GV.EIP_+=5;
5382 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5383 }
5384 else {
5385 if (!Security(3, pMyDisasm)) return;
5386 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
5387 #ifndef BEA_LIGHT_DISASSEMBLY
5388 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
5389 #endif
5390 GV.EIP_+=3;
5391 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5392 }
5393
5394 if (GV.REX.B_ == 0) {
5395 #ifndef BEA_LIGHT_DISASSEMBLY
5396 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0]);
5397 #endif
5398 }
5399 else {
5400 #ifndef BEA_LIGHT_DISASSEMBLY
5401 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers8Bits[0+8]);
5402 #endif
5403 }
5404
5405}
5406
5407/* =======================================
5408 * 0a1h
5409 * ======================================= */
5410void __bea_callspec__ mov_eAXOv(PDISASM pMyDisasm)
5411{
5412 UInt64 MyAddress;
5413 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5414 #ifndef BEA_LIGHT_DISASSEMBLY
5415 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5416 #endif
5417 GV.RM_ = 5;
5418 GV.MOD_= 0;
5419 if (GV.AddressSize == 64) {
5420 if (!Security(9, pMyDisasm)) return;
5421 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
5422 #ifndef BEA_LIGHT_DISASSEMBLY
5423 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5424 #endif
5425 GV.EIP_+=9;
5426 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5427 }
5428 else if (GV.AddressSize == 32) {
5429 if (!Security(5, pMyDisasm)) return;
5430 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
5431 #ifndef BEA_LIGHT_DISASSEMBLY
5432 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
5433 #endif
5434 GV.EIP_+=5;
5435 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5436 }
5437 else {
5438 if (!Security(3, pMyDisasm)) return;
5439 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
5440 #ifndef BEA_LIGHT_DISASSEMBLY
5441 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
5442 #endif
5443 GV.EIP_+=3;
5444 (*pMyDisasm).Argument2.Memory.Displacement = (Int64)MyAddress;
5445 }
5446
5447 if (GV.REX.B_ == 0) {
5448 if (GV.OperandSize == 64) {
5449 GV.MemDecoration = Arg2qword;
5450 #ifndef BEA_LIGHT_DISASSEMBLY
5451 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
5452 #endif
5453 }
5454 else if (GV.OperandSize == 32) {
5455 GV.MemDecoration = Arg2dword;
5456 #ifndef BEA_LIGHT_DISASSEMBLY
5457 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
5458 #endif
5459 }
5460 else {
5461 GV.MemDecoration = Arg2word;
5462 #ifndef BEA_LIGHT_DISASSEMBLY
5463 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
5464 #endif
5465 }
5466 }
5467 else {
5468 if (GV.OperandSize == 64) {
5469 GV.MemDecoration = Arg2qword;
5470 #ifndef BEA_LIGHT_DISASSEMBLY
5471 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0+8]);
5472 #endif
5473 }
5474 else if (GV.OperandSize == 32) {
5475 GV.MemDecoration = Arg2dword;
5476 #ifndef BEA_LIGHT_DISASSEMBLY
5477 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0+8]);
5478 #endif
5479 }
5480 else {
5481 GV.MemDecoration = Arg2word;
5482 #ifndef BEA_LIGHT_DISASSEMBLY
5483 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0+8]);
5484 #endif
5485 }
5486 }
5487 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
5488 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE ;
5489 if (GV.MemDecoration == 104) {
5490 (*pMyDisasm).Argument1.ArgSize = 64;
5491 (*pMyDisasm).Argument2.ArgSize = 64;
5492 }
5493 else if (GV.MemDecoration == 103) {
5494 (*pMyDisasm).Argument1.ArgSize = 32;
5495 (*pMyDisasm).Argument2.ArgSize = 32;
5496 }
5497 else if (GV.MemDecoration == 102) {
5498 (*pMyDisasm).Argument1.ArgSize = 16;
5499 (*pMyDisasm).Argument2.ArgSize = 16;
5500 }
5501
5502}
5503
5504/* =======================================
5505 * 0a2h
5506 * ======================================= */
5507void __bea_callspec__ mov_ObAL(PDISASM pMyDisasm)
5508{
5509 UInt64 MyAddress;
5510 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5511 #ifndef BEA_LIGHT_DISASSEMBLY
5512 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5513 #endif
5514 GV.MemDecoration = Arg1byte;
5515 GV.RM_ = 5;
5516 GV.MOD_= 0;
5517 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
5518 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE ;
5519 (*pMyDisasm).Argument1.ArgSize = 8;
5520 (*pMyDisasm).Argument2.ArgSize = 8;
5521 if (GV.AddressSize == 64) {
5522 if (!Security(9, pMyDisasm)) return;
5523 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
5524 #ifndef BEA_LIGHT_DISASSEMBLY
5525 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5526 #endif
5527 GV.EIP_+=9;
5528 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5529 }
5530 else if (GV.AddressSize == 32) {
5531 if (!Security(5, pMyDisasm)) return;
5532 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
5533 #ifndef BEA_LIGHT_DISASSEMBLY
5534 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
5535 #endif
5536 GV.EIP_+=5;
5537 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5538 }
5539 else {
5540 if (!Security(3, pMyDisasm)) return;
5541 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
5542 #ifndef BEA_LIGHT_DISASSEMBLY
5543 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
5544 #endif
5545 GV.EIP_+=3;
5546 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5547 }
5548
5549 if (GV.REX.B_ == 0) {
5550 #ifndef BEA_LIGHT_DISASSEMBLY
5551 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[0]);
5552 #endif
5553 }
5554 else {
5555 #ifndef BEA_LIGHT_DISASSEMBLY
5556 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers8Bits[0+8]);
5557 #endif
5558 }
5559
5560}
5561
5562/* =======================================
5563 * 0a3h
5564 * ======================================= */
5565void __bea_callspec__ mov_OveAX(PDISASM pMyDisasm)
5566{
5567 UInt64 MyAddress;
5568 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5569 #ifndef BEA_LIGHT_DISASSEMBLY
5570 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5571 #endif
5572 GV.RM_ = 5;
5573 GV.MOD_= 0;
5574 if (GV.AddressSize == 64) {
5575 if (!Security(9, pMyDisasm)) return;
5576 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
5577 #ifndef BEA_LIGHT_DISASSEMBLY
5578 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.16llX",(Int64) MyAddress);
5579 #endif
5580 GV.EIP_+=9;
5581 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5582 }
5583 else if (GV.AddressSize == 32) {
5584 if (!Security(5, pMyDisasm)) return;
5585 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
5586 #ifndef BEA_LIGHT_DISASSEMBLY
5587 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.8X",(Int64) MyAddress);
5588 #endif
5589 GV.EIP_+=5;
5590 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5591 }
5592 else {
5593 if (!Security(3, pMyDisasm)) return;
5594 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
5595 #ifndef BEA_LIGHT_DISASSEMBLY
5596 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument1.ArgMnemonic, "%.4X",(Int64) MyAddress);
5597 #endif
5598 GV.EIP_+=3;
5599 (*pMyDisasm).Argument1.Memory.Displacement = (Int64)MyAddress;
5600 }
5601
5602 if (GV.REX.B_ == 0) {
5603 if (GV.OperandSize == 64) {
5604 GV.MemDecoration = Arg1qword;
5605 #ifndef BEA_LIGHT_DISASSEMBLY
5606 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[0]);
5607 #endif
5608 }
5609 else if (GV.OperandSize == 32) {
5610 GV.MemDecoration = Arg1dword;
5611 #ifndef BEA_LIGHT_DISASSEMBLY
5612 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0]);
5613 #endif
5614 }
5615 else {
5616 GV.MemDecoration = Arg1word;
5617 #ifndef BEA_LIGHT_DISASSEMBLY
5618 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0]);
5619 #endif
5620 }
5621 }
5622 else {
5623 if (GV.OperandSize == 64) {
5624 GV.MemDecoration = Arg1qword;
5625 #ifndef BEA_LIGHT_DISASSEMBLY
5626 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers64Bits[0+8]);
5627 #endif
5628 }
5629 else if (GV.OperandSize == 32) {
5630 GV.MemDecoration = Arg1dword;
5631 #ifndef BEA_LIGHT_DISASSEMBLY
5632 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers32Bits[0+8]);
5633 #endif
5634 }
5635 else {
5636 GV.MemDecoration = Arg1word;
5637 #ifndef BEA_LIGHT_DISASSEMBLY
5638 (void) strcpy ((char*) (*pMyDisasm).Argument2.ArgMnemonic, Registers16Bits[0+8]);
5639 #endif
5640 }
5641 }
5642
5643 (*pMyDisasm).Argument2.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
5644 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE ;
5645 if (GV.MemDecoration == Arg1qword) {
5646 (*pMyDisasm).Argument1.ArgSize = 64;
5647 (*pMyDisasm).Argument2.ArgSize = 64;
5648 }
5649 else if (GV.MemDecoration == Arg1dword) {
5650 (*pMyDisasm).Argument1.ArgSize = 32;
5651 (*pMyDisasm).Argument2.ArgSize = 32;
5652 }
5653 else if (GV.MemDecoration == Arg1word) {
5654 (*pMyDisasm).Argument1.ArgSize = 16;
5655 (*pMyDisasm).Argument2.ArgSize = 16;
5656 }
5657}
5658
5659/* =======================================
5660 * 0b0h
5661 * ======================================= */
5662void __bea_callspec__ mov_ALIb(PDISASM pMyDisasm)
5663{
5664 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5665 #ifndef BEA_LIGHT_DISASSEMBLY
5666 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5667 #endif
5668 ALIb(pMyDisasm);
5669}
5670
5671/* =======================================
5672 * 0b1h
5673 * ======================================= */
5674void __bea_callspec__ mov_CLIb(PDISASM pMyDisasm)
5675{
5676 long MyNumber;
5677 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5678 #ifndef BEA_LIGHT_DISASSEMBLY
5679 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5680 #endif
5681 if (!Security(2, pMyDisasm)) return;
5682 GV.ImmediatSize = 8;
5683 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5684 #ifndef BEA_LIGHT_DISASSEMBLY
5685 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5686 #endif
5687 (*pMyDisasm).Instruction.Immediat = MyNumber;
5688 #ifndef BEA_LIGHT_DISASSEMBLY
5689 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[1]);
5690 #endif
5691 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
5692 (*pMyDisasm).Argument1.ArgSize = 8;
5693 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5694 (*pMyDisasm).Argument2.ArgSize = 8;
5695 GV.EIP_ += 2;
5696}
5697
5698/* =======================================
5699 * 0b2h
5700 * ======================================= */
5701void __bea_callspec__ mov_DLIb(PDISASM pMyDisasm)
5702{
5703 long MyNumber;
5704 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5705 #ifndef BEA_LIGHT_DISASSEMBLY
5706 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5707 #endif
5708 if (!Security(2, pMyDisasm)) return;
5709 GV.ImmediatSize = 8;
5710 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5711 #ifndef BEA_LIGHT_DISASSEMBLY
5712 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5713 #endif
5714 (*pMyDisasm).Instruction.Immediat = MyNumber;
5715 #ifndef BEA_LIGHT_DISASSEMBLY
5716 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[2]);
5717 #endif
5718 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
5719 (*pMyDisasm).Argument1.ArgSize = 8;
5720 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5721 (*pMyDisasm).Argument2.ArgSize = 8;
5722 GV.EIP_ += 2;
5723}
5724
5725/* =======================================
5726 * 0b3h
5727 * ======================================= */
5728void __bea_callspec__ mov_BLIb(PDISASM pMyDisasm)
5729{
5730 long MyNumber;
5731 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5732 #ifndef BEA_LIGHT_DISASSEMBLY
5733 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5734 #endif
5735 if (!Security(2, pMyDisasm)) return;
5736 GV.ImmediatSize = 8;
5737 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5738 #ifndef BEA_LIGHT_DISASSEMBLY
5739 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5740 #endif
5741 (*pMyDisasm).Instruction.Immediat = MyNumber;
5742 #ifndef BEA_LIGHT_DISASSEMBLY
5743 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[3]);
5744 #endif
5745 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
5746 (*pMyDisasm).Argument1.ArgSize = 8;
5747 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5748 (*pMyDisasm).Argument2.ArgSize = 8;
5749 GV.EIP_ += 2;
5750}
5751
5752/* =======================================
5753 * 0b4h
5754 * ======================================= */
5755void __bea_callspec__ mov_AHIb(PDISASM pMyDisasm)
5756{
5757 long MyNumber;
5758 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5759 #ifndef BEA_LIGHT_DISASSEMBLY
5760 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5761 #endif
5762 if (!Security(2, pMyDisasm)) return;
5763 GV.ImmediatSize = 8;
5764 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5765 #ifndef BEA_LIGHT_DISASSEMBLY
5766 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5767 #endif
5768 (*pMyDisasm).Instruction.Immediat = MyNumber;
5769 #ifndef BEA_LIGHT_DISASSEMBLY
5770 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[4]);
5771 #endif
5772 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
5773 (*pMyDisasm).Argument1.ArgPosition = HighPosition;
5774 (*pMyDisasm).Argument1.ArgSize = 8;
5775 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5776 (*pMyDisasm).Argument2.ArgSize = 8;
5777 GV.EIP_ += 2;
5778}
5779
5780/* =======================================
5781 * 0b5h
5782 * ======================================= */
5783void __bea_callspec__ mov_CHIb(PDISASM pMyDisasm)
5784{
5785 long MyNumber;
5786 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5787 #ifndef BEA_LIGHT_DISASSEMBLY
5788 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5789 #endif
5790 if (!Security(2, pMyDisasm)) return;
5791 GV.ImmediatSize = 8;
5792 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5793 #ifndef BEA_LIGHT_DISASSEMBLY
5794 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5795 #endif
5796 (*pMyDisasm).Instruction.Immediat = MyNumber;
5797 #ifndef BEA_LIGHT_DISASSEMBLY
5798 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[5]);
5799 #endif
5800 (*pMyDisasm).Argument1.ArgPosition = HighPosition;
5801 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
5802 (*pMyDisasm).Argument1.ArgSize = 8;
5803 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5804 (*pMyDisasm).Argument2.ArgSize = 8;
5805 GV.EIP_ += 2;
5806}
5807
5808/* =======================================
5809 * 0b6h
5810 * ======================================= */
5811void __bea_callspec__ mov_DHIb(PDISASM pMyDisasm)
5812{
5813 long MyNumber;
5814 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5815 #ifndef BEA_LIGHT_DISASSEMBLY
5816 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5817 #endif
5818 if (!Security(2, pMyDisasm)) return;
5819 GV.ImmediatSize = 8;
5820 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5821 #ifndef BEA_LIGHT_DISASSEMBLY
5822 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5823 #endif
5824 (*pMyDisasm).Instruction.Immediat = MyNumber;
5825 #ifndef BEA_LIGHT_DISASSEMBLY
5826 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[6]);
5827 #endif
5828 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
5829 (*pMyDisasm).Argument1.ArgPosition = HighPosition;
5830 (*pMyDisasm).Argument1.ArgSize = 8;
5831 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5832 (*pMyDisasm).Argument2.ArgSize = 8;
5833 GV.EIP_ += 2;
5834}
5835
5836/* =======================================
5837 * 0b7h
5838 * ======================================= */
5839void __bea_callspec__ mov_BHIb(PDISASM pMyDisasm)
5840{
5841 long MyNumber;
5842 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5843 #ifndef BEA_LIGHT_DISASSEMBLY
5844 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
5845 #endif
5846 if (!Security(2, pMyDisasm)) return;
5847 GV.ImmediatSize = 8;
5848 MyNumber = *((UInt8*)(UIntPtr) (GV.EIP_+1));
5849 #ifndef BEA_LIGHT_DISASSEMBLY
5850 (void) CopyFormattedNumber(pMyDisasm, (char*) &(*pMyDisasm).Argument2.ArgMnemonic,"%.2X",(Int64) MyNumber);
5851 #endif
5852 (*pMyDisasm).Instruction.Immediat = MyNumber;
5853 #ifndef BEA_LIGHT_DISASSEMBLY
5854 (void) strcpy((char*) &(*pMyDisasm).Argument1.ArgMnemonic, Registers8BitsLegacy[7]);
5855 #endif
5856 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
5857 (*pMyDisasm).Argument1.ArgPosition = HighPosition;
5858 (*pMyDisasm).Argument1.ArgSize = 8;
5859 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
5860 (*pMyDisasm).Argument2.ArgSize = 8;
5861 GV.EIP_ += 2;
5862}
5863
5864
5865/* =======================================
5866 * 0a4h
5867 * ======================================= */
5868void __bea_callspec__ movs_(PDISASM pMyDisasm)
5869{
5870 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
5871 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
5872 }
5873 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
5874 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
5875 }
5876 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
5877 #ifndef BEA_LIGHT_DISASSEMBLY
5878 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsb ");
5879 #endif
5880 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
5881 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
5882 (*pMyDisasm).Argument1.ArgSize = 8;
5883 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
5884 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
5885 (*pMyDisasm).Argument2.ArgSize = 8;
5886 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
5887 GV.EIP_++;
5888 FillFlags(pMyDisasm, 68);
5889}
5890
5891/* =======================================
5892 * 0a5h
5893 * ======================================= */
5894void __bea_callspec__ movsw_(PDISASM pMyDisasm)
5895{
5896 if ((*pMyDisasm).Prefix.RepnePrefix == SuperfluousPrefix) {
5897 (*pMyDisasm).Prefix.RepnePrefix = InUsePrefix;
5898 }
5899 if ((*pMyDisasm).Prefix.RepPrefix == SuperfluousPrefix) {
5900 (*pMyDisasm).Prefix.RepPrefix = InUsePrefix;
5901 }
5902 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+STRING_INSTRUCTION;
5903 if (GV.OperandSize == 64) {
5904 #ifndef BEA_LIGHT_DISASSEMBLY
5905 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsq ");
5906 #endif
5907 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
5908 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
5909 (*pMyDisasm).Argument1.ArgSize = 64;
5910 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
5911 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
5912 (*pMyDisasm).Argument2.ArgSize = 64;
5913 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
5914 GV.EIP_++;
5915 FillFlags(pMyDisasm, 68);
5916 }
5917 else if (GV.OperandSize == 32) {
5918 #ifndef BEA_LIGHT_DISASSEMBLY
5919 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsd ");
5920 #endif
5921 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
5922 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
5923 (*pMyDisasm).Argument1.ArgSize = 32;
5924 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
5925 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
5926 (*pMyDisasm).Argument2.ArgSize = 32;
5927 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
5928 GV.EIP_++;
5929 FillFlags(pMyDisasm, 68);
5930 }
5931 else {
5932 #ifndef BEA_LIGHT_DISASSEMBLY
5933 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsw ");
5934 #endif
5935 (*pMyDisasm).Argument1.ArgType = MEMORY_TYPE;
5936 (*pMyDisasm).Argument1.Memory.BaseRegister = REG7;
5937 (*pMyDisasm).Argument1.ArgSize = 16;
5938 (*pMyDisasm).Argument2.ArgType = MEMORY_TYPE;
5939 (*pMyDisasm).Argument2.Memory.BaseRegister = REG6;
5940 (*pMyDisasm).Argument2.ArgSize = 16;
5941 (*pMyDisasm).Instruction.ImplicitModifiedRegs = GENERAL_REG+REG6+REG7;
5942 GV.EIP_++;
5943 FillFlags(pMyDisasm, 68);
5944 }
5945}
5946
5947/* =======================================
5948 * 0fb6h
5949 * ======================================= */
5950void __bea_callspec__ movzx_GvEb(PDISASM pMyDisasm)
5951{
5952 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5953 #ifndef BEA_LIGHT_DISASSEMBLY
5954 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movzx ");
5955 #endif
5956 GvEb(pMyDisasm);
5957}
5958
5959
5960/* =======================================
5961 * 0fbeh
5962 * ======================================= */
5963void __bea_callspec__ movsx_GvEb(PDISASM pMyDisasm)
5964{
5965 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5966 #ifndef BEA_LIGHT_DISASSEMBLY
5967 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsx ");
5968 #endif
5969 GvEb(pMyDisasm);
5970}
5971
5972/* =======================================
5973 * 0fbfh
5974 * ======================================= */
5975void __bea_callspec__ movsx_GvEw(PDISASM pMyDisasm)
5976{
5977 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5978 #ifndef BEA_LIGHT_DISASSEMBLY
5979 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsx ");
5980 #endif
5981 GvEw(pMyDisasm);
5982}
5983
5984/* =======================================
5985 * 0fb7h
5986 * ======================================= */
5987void __bea_callspec__ movzx_GvEw(PDISASM pMyDisasm)
5988{
5989 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
5990 #ifndef BEA_LIGHT_DISASSEMBLY
5991 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movzx ");
5992 #endif
5993 GvEw(pMyDisasm);
5994}
5995
5996/* =======================================
5997 * 0b8h
5998 * ======================================= */
5999void __bea_callspec__ mov_EAX(PDISASM pMyDisasm)
6000{
6001 UInt64 MyAddress;
6002 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6003 #ifndef BEA_LIGHT_DISASSEMBLY
6004 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6005 #endif
6006 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG0;
6007 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6008 if (GV.OperandSize == 64) {
6009 if (!Security(9, pMyDisasm)) return;
6010 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6011 #ifndef BEA_LIGHT_DISASSEMBLY
6012 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6013 #endif
6014 GV.EIP_+=9;
6015 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6016 (*pMyDisasm).Argument1.ArgSize = 64;
6017 (*pMyDisasm).Argument2.ArgSize = 64;
6018 }
6019 else if (GV.OperandSize == 32) {
6020 if (!Security(5, pMyDisasm)) return;
6021 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6022 #ifndef BEA_LIGHT_DISASSEMBLY
6023 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6024 #endif
6025 GV.EIP_+=5;
6026 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6027 (*pMyDisasm).Argument1.ArgSize = 32;
6028 (*pMyDisasm).Argument2.ArgSize = 32;
6029 }
6030 else {
6031 if (!Security(3, pMyDisasm)) return;
6032 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6033 #ifndef BEA_LIGHT_DISASSEMBLY
6034 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6035 #endif
6036 GV.EIP_+=3;
6037 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6038 (*pMyDisasm).Argument1.ArgSize = 16;
6039 (*pMyDisasm).Argument2.ArgSize = 16;
6040 }
6041
6042 if (GV.REX.B_ == 0) {
6043 if (GV.OperandSize == 64) {
6044 #ifndef BEA_LIGHT_DISASSEMBLY
6045 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0]);
6046 #endif
6047 }
6048 else if (GV.OperandSize == 32) {
6049 #ifndef BEA_LIGHT_DISASSEMBLY
6050 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0]);
6051 #endif
6052 }
6053 else {
6054 #ifndef BEA_LIGHT_DISASSEMBLY
6055 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0]);
6056 #endif
6057 }
6058 }
6059 else {
6060 if (GV.OperandSize == 64) {
6061 #ifndef BEA_LIGHT_DISASSEMBLY
6062 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[0+8]);
6063 #endif
6064 }
6065 else if (GV.OperandSize == 32) {
6066 #ifndef BEA_LIGHT_DISASSEMBLY
6067 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[0+8]);
6068 #endif
6069 }
6070 else {
6071 #ifndef BEA_LIGHT_DISASSEMBLY
6072 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[0+8]);
6073 #endif
6074 }
6075 }
6076
6077}
6078
6079/* =======================================
6080 * 0b9h
6081 * ======================================= */
6082void __bea_callspec__ mov_ECX(PDISASM pMyDisasm)
6083{
6084 UInt64 MyAddress;
6085 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6086 #ifndef BEA_LIGHT_DISASSEMBLY
6087 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6088 #endif
6089 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG1;
6090 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6091 if (GV.OperandSize == 64) {
6092 if (!Security(9, pMyDisasm)) return;
6093 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6094 #ifndef BEA_LIGHT_DISASSEMBLY
6095 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6096 #endif
6097 GV.EIP_+=9;
6098 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6099 (*pMyDisasm).Argument1.ArgSize = 64;
6100 (*pMyDisasm).Argument2.ArgSize = 64;
6101 }
6102 else if (GV.OperandSize == 32) {
6103 if (!Security(5, pMyDisasm)) return;
6104 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6105 #ifndef BEA_LIGHT_DISASSEMBLY
6106 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6107 #endif
6108 GV.EIP_+=5;
6109 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6110 (*pMyDisasm).Argument1.ArgSize = 32;
6111 (*pMyDisasm).Argument2.ArgSize = 32;
6112 }
6113 else {
6114 if (!Security(3, pMyDisasm)) return;
6115 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6116 #ifndef BEA_LIGHT_DISASSEMBLY
6117 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6118 #endif
6119 GV.EIP_+=3;
6120 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6121 (*pMyDisasm).Argument1.ArgSize = 16;
6122 (*pMyDisasm).Argument2.ArgSize = 16;
6123 }
6124
6125 if (GV.REX.B_ == 0) {
6126 if (GV.OperandSize == 64) {
6127 #ifndef BEA_LIGHT_DISASSEMBLY
6128 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+0]);
6129 #endif
6130 }
6131 else if (GV.OperandSize == 32) {
6132 #ifndef BEA_LIGHT_DISASSEMBLY
6133 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1+0]);
6134 #endif
6135 }
6136 else {
6137 #ifndef BEA_LIGHT_DISASSEMBLY
6138 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1+0]);
6139 #endif
6140 }
6141 }
6142 else {
6143 if (GV.OperandSize == 64) {
6144 #ifndef BEA_LIGHT_DISASSEMBLY
6145 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[1+0+8]);
6146 #endif
6147 }
6148 else if (GV.OperandSize == 32) {
6149 #ifndef BEA_LIGHT_DISASSEMBLY
6150 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[1+0+8]);
6151 #endif
6152 }
6153 else {
6154 #ifndef BEA_LIGHT_DISASSEMBLY
6155 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[1+0+8]);
6156 #endif
6157 }
6158 }
6159
6160}
6161
6162/* =======================================
6163 * 0bah
6164 * ======================================= */
6165void __bea_callspec__ mov_EDX(PDISASM pMyDisasm)
6166{
6167 UInt64 MyAddress;
6168 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6169 #ifndef BEA_LIGHT_DISASSEMBLY
6170 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6171 #endif
6172 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG2;
6173 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6174 if (GV.OperandSize == 64) {
6175 if (!Security(9, pMyDisasm)) return;
6176 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6177 #ifndef BEA_LIGHT_DISASSEMBLY
6178 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6179 #endif
6180 GV.EIP_+=9;
6181 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6182 (*pMyDisasm).Argument1.ArgSize = 64;
6183 (*pMyDisasm).Argument2.ArgSize = 64;
6184 }
6185 else if (GV.OperandSize == 32) {
6186 if (!Security(5, pMyDisasm)) return;
6187 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6188 #ifndef BEA_LIGHT_DISASSEMBLY
6189 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6190 #endif
6191 GV.EIP_+=5;
6192 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6193 (*pMyDisasm).Argument1.ArgSize = 32;
6194 (*pMyDisasm).Argument2.ArgSize = 32;
6195 }
6196 else {
6197 if (!Security(3, pMyDisasm)) return;
6198 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6199 #ifndef BEA_LIGHT_DISASSEMBLY
6200 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6201 #endif
6202 GV.EIP_+=3;
6203 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6204 (*pMyDisasm).Argument1.ArgSize = 16;
6205 (*pMyDisasm).Argument2.ArgSize = 16;
6206 }
6207
6208 if (GV.REX.B_ == 0) {
6209 if (GV.OperandSize == 64) {
6210 #ifndef BEA_LIGHT_DISASSEMBLY
6211 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+0]);
6212 #endif
6213 }
6214 else if (GV.OperandSize == 32) {
6215 #ifndef BEA_LIGHT_DISASSEMBLY
6216 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2+0]);
6217 #endif
6218 }
6219 else {
6220 #ifndef BEA_LIGHT_DISASSEMBLY
6221 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2+0]);
6222 #endif
6223 }
6224 }
6225 else {
6226 if (GV.OperandSize == 64) {
6227 #ifndef BEA_LIGHT_DISASSEMBLY
6228 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[2+0+8]);
6229 #endif
6230 }
6231 else if (GV.OperandSize == 32) {
6232 #ifndef BEA_LIGHT_DISASSEMBLY
6233 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[2+0+8]);
6234 #endif
6235 }
6236 else {
6237 #ifndef BEA_LIGHT_DISASSEMBLY
6238 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[2+0+8]);
6239 #endif
6240 }
6241 }
6242
6243}
6244
6245/* =======================================
6246 * 0bbh
6247 * ======================================= */
6248void __bea_callspec__ mov_EBX(PDISASM pMyDisasm)
6249{
6250 UInt64 MyAddress;
6251 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6252 #ifndef BEA_LIGHT_DISASSEMBLY
6253 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6254 #endif
6255 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG3;
6256 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6257 if (GV.OperandSize == 64) {
6258 if (!Security(9, pMyDisasm)) return;
6259 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6260 #ifndef BEA_LIGHT_DISASSEMBLY
6261 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6262 #endif
6263 GV.EIP_+=9;
6264 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6265 (*pMyDisasm).Argument1.ArgSize = 64;
6266 (*pMyDisasm).Argument2.ArgSize = 64;
6267 }
6268 else if (GV.OperandSize == 32) {
6269 if (!Security(5, pMyDisasm)) return;
6270 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6271 #ifndef BEA_LIGHT_DISASSEMBLY
6272 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6273 #endif
6274 GV.EIP_+=5;
6275 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6276 (*pMyDisasm).Argument1.ArgSize = 32;
6277 (*pMyDisasm).Argument2.ArgSize = 32;
6278 }
6279 else {
6280 if (!Security(3, pMyDisasm)) return;
6281 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6282 #ifndef BEA_LIGHT_DISASSEMBLY
6283 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6284 #endif
6285 GV.EIP_+=3;
6286 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6287 (*pMyDisasm).Argument1.ArgSize = 16;
6288 (*pMyDisasm).Argument2.ArgSize = 16;
6289 }
6290
6291 if (GV.REX.B_ == 0) {
6292 if (GV.OperandSize == 64) {
6293 #ifndef BEA_LIGHT_DISASSEMBLY
6294 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+0]);
6295 #endif
6296 }
6297 else if (GV.OperandSize == 32) {
6298 #ifndef BEA_LIGHT_DISASSEMBLY
6299 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3+0]);
6300 #endif
6301 }
6302 else {
6303 #ifndef BEA_LIGHT_DISASSEMBLY
6304 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3+0]);
6305 #endif
6306 }
6307 }
6308 else {
6309 if (GV.OperandSize == 64) {
6310 #ifndef BEA_LIGHT_DISASSEMBLY
6311 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[3+0+8]);
6312 #endif
6313 }
6314 else if (GV.OperandSize == 32) {
6315 #ifndef BEA_LIGHT_DISASSEMBLY
6316 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[3+0+8]);
6317 #endif
6318 }
6319 else {
6320 #ifndef BEA_LIGHT_DISASSEMBLY
6321 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[3+0+8]);
6322 #endif
6323 }
6324 }
6325
6326}
6327
6328/* =======================================
6329 * 0bch
6330 * ======================================= */
6331void __bea_callspec__ mov_ESP(PDISASM pMyDisasm)
6332{
6333 UInt64 MyAddress;
6334 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6335 #ifndef BEA_LIGHT_DISASSEMBLY
6336 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6337 #endif
6338 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG4;
6339 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6340 if (GV.OperandSize == 64) {
6341 if (!Security(9, pMyDisasm)) return;
6342 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6343 #ifndef BEA_LIGHT_DISASSEMBLY
6344 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6345 #endif
6346 GV.EIP_+=9;
6347 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6348 (*pMyDisasm).Argument1.ArgSize = 64;
6349 (*pMyDisasm).Argument2.ArgSize = 64;
6350 }
6351 else if (GV.OperandSize == 32) {
6352 if (!Security(5, pMyDisasm)) return;
6353 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6354 #ifndef BEA_LIGHT_DISASSEMBLY
6355 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6356 #endif
6357 GV.EIP_+=5;
6358 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6359 (*pMyDisasm).Argument1.ArgSize = 32;
6360 (*pMyDisasm).Argument2.ArgSize = 32;
6361 }
6362 else {
6363 if (!Security(3, pMyDisasm)) return;
6364 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6365 #ifndef BEA_LIGHT_DISASSEMBLY
6366 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6367 #endif
6368 GV.EIP_+=3;
6369 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6370 (*pMyDisasm).Argument1.ArgSize = 16;
6371 (*pMyDisasm).Argument2.ArgSize = 16;
6372 }
6373
6374 if (GV.REX.B_ == 0) {
6375 if (GV.OperandSize == 64) {
6376 #ifndef BEA_LIGHT_DISASSEMBLY
6377 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+0]);
6378 #endif
6379 }
6380 else if (GV.OperandSize == 32) {
6381 #ifndef BEA_LIGHT_DISASSEMBLY
6382 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4+0]);
6383 #endif
6384 }
6385 else {
6386 #ifndef BEA_LIGHT_DISASSEMBLY
6387 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4+0]);
6388 #endif
6389 }
6390 }
6391 else {
6392 if (GV.OperandSize == 64) {
6393 #ifndef BEA_LIGHT_DISASSEMBLY
6394 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[4+0+8]);
6395 #endif
6396 }
6397 else if (GV.OperandSize == 32) {
6398 #ifndef BEA_LIGHT_DISASSEMBLY
6399 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[4+0+8]);
6400 #endif
6401 }
6402 else {
6403 #ifndef BEA_LIGHT_DISASSEMBLY
6404 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[4+0+8]);
6405 #endif
6406 }
6407 }
6408
6409}
6410
6411/* =======================================
6412 * 0bdh
6413 * ======================================= */
6414void __bea_callspec__ mov_EBP(PDISASM pMyDisasm)
6415{
6416 UInt64 MyAddress;
6417 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6418 #ifndef BEA_LIGHT_DISASSEMBLY
6419 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6420 #endif
6421 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG5;
6422 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6423 if (GV.OperandSize == 64) {
6424 if (!Security(9, pMyDisasm)) return;
6425 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6426 #ifndef BEA_LIGHT_DISASSEMBLY
6427 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6428 #endif
6429 GV.EIP_+=9;
6430 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6431 (*pMyDisasm).Argument1.ArgSize = 64;
6432 (*pMyDisasm).Argument2.ArgSize = 64;
6433 }
6434 else if (GV.OperandSize == 32) {
6435 if (!Security(5, pMyDisasm)) return;
6436 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6437 #ifndef BEA_LIGHT_DISASSEMBLY
6438 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6439 #endif
6440 GV.EIP_+=5;
6441 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6442 (*pMyDisasm).Argument1.ArgSize = 32;
6443 (*pMyDisasm).Argument2.ArgSize = 32;
6444 }
6445 else {
6446 if (!Security(3, pMyDisasm)) return;
6447 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6448 #ifndef BEA_LIGHT_DISASSEMBLY
6449 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6450 #endif
6451 GV.EIP_+=3;
6452 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6453 (*pMyDisasm).Argument1.ArgSize = 16;
6454 (*pMyDisasm).Argument2.ArgSize = 16;
6455 }
6456
6457 if (GV.REX.B_ == 0) {
6458 if (GV.OperandSize == 64) {
6459 #ifndef BEA_LIGHT_DISASSEMBLY
6460 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+0]);
6461 #endif
6462 }
6463 else if (GV.OperandSize == 32) {
6464 #ifndef BEA_LIGHT_DISASSEMBLY
6465 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5+0]);
6466 #endif
6467 }
6468 else {
6469 #ifndef BEA_LIGHT_DISASSEMBLY
6470 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5+0]);
6471 #endif
6472 }
6473 }
6474 else {
6475 if (GV.OperandSize == 64) {
6476 #ifndef BEA_LIGHT_DISASSEMBLY
6477 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[5+0+8]);
6478 #endif
6479 }
6480 else if (GV.OperandSize == 32) {
6481 #ifndef BEA_LIGHT_DISASSEMBLY
6482 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[5+0+8]);
6483 #endif
6484 }
6485 else {
6486 #ifndef BEA_LIGHT_DISASSEMBLY
6487 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[5+0+8]);
6488 #endif
6489 }
6490 }
6491
6492}
6493
6494/* =======================================
6495 * 0beh
6496 * ======================================= */
6497void __bea_callspec__ mov_ESI(PDISASM pMyDisasm)
6498{
6499 UInt64 MyAddress;
6500 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6501 #ifndef BEA_LIGHT_DISASSEMBLY
6502 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6503 #endif
6504 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG6;
6505 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6506 if (GV.OperandSize == 64) {
6507 if (!Security(9, pMyDisasm)) return;
6508 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6509 #ifndef BEA_LIGHT_DISASSEMBLY
6510 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6511 #endif
6512 GV.EIP_+=9;
6513 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6514 (*pMyDisasm).Argument1.ArgSize = 64;
6515 (*pMyDisasm).Argument2.ArgSize = 64;
6516 }
6517 else if (GV.OperandSize == 32) {
6518 if (!Security(5, pMyDisasm)) return;
6519 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6520 #ifndef BEA_LIGHT_DISASSEMBLY
6521 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6522 #endif
6523 GV.EIP_+=5;
6524 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6525 (*pMyDisasm).Argument1.ArgSize = 32;
6526 (*pMyDisasm).Argument2.ArgSize = 32;
6527 }
6528 else {
6529 if (!Security(3, pMyDisasm)) return;
6530 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6531 #ifndef BEA_LIGHT_DISASSEMBLY
6532 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6533 #endif
6534 GV.EIP_+=3;
6535 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6536 (*pMyDisasm).Argument1.ArgSize = 16;
6537 (*pMyDisasm).Argument2.ArgSize = 16;
6538 }
6539
6540 if (GV.REX.B_ == 0) {
6541 if (GV.OperandSize == 64) {
6542 #ifndef BEA_LIGHT_DISASSEMBLY
6543 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+0]);
6544 #endif
6545 }
6546 else if (GV.OperandSize == 32) {
6547 #ifndef BEA_LIGHT_DISASSEMBLY
6548 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6+0]);
6549 #endif
6550 }
6551 else {
6552 #ifndef BEA_LIGHT_DISASSEMBLY
6553 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6+0]);
6554 #endif
6555 }
6556 }
6557 else {
6558 if (GV.OperandSize == 64) {
6559 #ifndef BEA_LIGHT_DISASSEMBLY
6560 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[6+0+8]);
6561 #endif
6562 }
6563 else if (GV.OperandSize == 32) {
6564 #ifndef BEA_LIGHT_DISASSEMBLY
6565 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[6+0+8]);
6566 #endif
6567 }
6568 else {
6569 #ifndef BEA_LIGHT_DISASSEMBLY
6570 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[6+0+8]);
6571 #endif
6572 }
6573 }
6574
6575}
6576
6577/* =======================================
6578 * 0bfh
6579 * ======================================= */
6580void __bea_callspec__ mov_EDI(PDISASM pMyDisasm)
6581{
6582 UInt64 MyAddress;
6583 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6584 #ifndef BEA_LIGHT_DISASSEMBLY
6585 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6586 #endif
6587 (*pMyDisasm).Argument1.ArgType = REGISTER_TYPE+GENERAL_REG+REG7;
6588 (*pMyDisasm).Argument2.ArgType = CONSTANT_TYPE+ABSOLUTE_;
6589 if (GV.OperandSize == 64) {
6590 if (!Security(9, pMyDisasm)) return;
6591 MyAddress = *((UInt64 *)(UIntPtr) (GV.EIP_+1));
6592 #ifndef BEA_LIGHT_DISASSEMBLY
6593 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.16llX",(Int64) MyAddress);
6594 #endif
6595 GV.EIP_+=9;
6596 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6597 (*pMyDisasm).Argument1.ArgSize = 64;
6598 (*pMyDisasm).Argument2.ArgSize = 64;
6599 }
6600 else if (GV.OperandSize == 32) {
6601 if (!Security(5, pMyDisasm)) return;
6602 MyAddress = *((UInt32*)(UIntPtr) (GV.EIP_+1));
6603 #ifndef BEA_LIGHT_DISASSEMBLY
6604 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.8X",(Int64) MyAddress);
6605 #endif
6606 GV.EIP_+=5;
6607 (*pMyDisasm).Instruction.Immediat = (Int64)MyAddress;
6608 (*pMyDisasm).Argument1.ArgSize = 32;
6609 (*pMyDisasm).Argument2.ArgSize = 32;
6610 }
6611 else {
6612 if (!Security(3, pMyDisasm)) return;
6613 MyAddress = *((UInt16*)(UIntPtr) (GV.EIP_+1));
6614 #ifndef BEA_LIGHT_DISASSEMBLY
6615 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument2.ArgMnemonic, "%.4X",(Int64) MyAddress);
6616 #endif
6617 GV.EIP_+=3;
6618 (*pMyDisasm).Instruction.Immediat = (Int64) MyAddress;
6619 (*pMyDisasm).Argument1.ArgSize = 16;
6620 (*pMyDisasm).Argument2.ArgSize = 16;
6621 }
6622
6623 if (GV.REX.B_ == 0) {
6624 if (GV.OperandSize == 64) {
6625 #ifndef BEA_LIGHT_DISASSEMBLY
6626 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+0]);
6627 #endif
6628 }
6629 else if (GV.OperandSize == 32) {
6630 #ifndef BEA_LIGHT_DISASSEMBLY
6631 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7+0]);
6632 #endif
6633 }
6634 else {
6635 #ifndef BEA_LIGHT_DISASSEMBLY
6636 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7+0]);
6637 #endif
6638 }
6639 }
6640 else {
6641 if (GV.OperandSize == 64) {
6642 #ifndef BEA_LIGHT_DISASSEMBLY
6643 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers64Bits[7+0+8]);
6644 #endif
6645 }
6646 else if (GV.OperandSize == 32) {
6647 #ifndef BEA_LIGHT_DISASSEMBLY
6648 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers32Bits[7+0+8]);
6649 #endif
6650 }
6651 else {
6652 #ifndef BEA_LIGHT_DISASSEMBLY
6653 (void) strcpy ((char*) (*pMyDisasm).Argument1.ArgMnemonic, Registers16Bits[7+0+8]);
6654 #endif
6655 }
6656 }
6657
6658}
6659/* =======================================
6660 * 0c6h-Group 11
6661 * ======================================= */
6662void __bea_callspec__ mov_EbIb(PDISASM pMyDisasm)
6663{
6664 GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
6665 if (GV.REGOPCODE == 0) {
6666 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6667 #ifndef BEA_LIGHT_DISASSEMBLY
6668 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6669 #endif
6670 EbIb(pMyDisasm);
6671 }
6672 else {
6673 FailDecode(pMyDisasm);
6674 }
6675}
6676
6677/* =======================================
6678 * 0c7h-Group 11
6679 * ======================================= */
6680void __bea_callspec__ mov_EvIv(PDISASM pMyDisasm)
6681{
6682 GV.REGOPCODE = ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 3) & 0x7;
6683 if (GV.REGOPCODE == 0) {
6684 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6685 #ifndef BEA_LIGHT_DISASSEMBLY
6686 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6687 #endif
6688 EvIv(pMyDisasm);
6689 }
6690 else {
6691 FailDecode(pMyDisasm);
6692 }
6693}
6694
6695/* =======================================
6696 * 08ch
6697 * ======================================= */
6698void __bea_callspec__ mov_EwSreg(PDISASM pMyDisasm)
6699{
6700 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6701 #ifndef BEA_LIGHT_DISASSEMBLY
6702 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6703 #endif
6704 GV.MemDecoration = Arg1word;
6705 GV.OperandSize = 16;
6706 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
6707 GV.OperandSize = 32;
6708 GV.SEG_ = 1;
6709 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
6710 GV.SEG_ = 0;
6711 GV.EIP_ += GV.DECALAGE_EIP+2;
6712}
6713
6714/* =======================================
6715 * 08eh
6716 * ======================================= */
6717void __bea_callspec__ mov_SregEw(PDISASM pMyDisasm)
6718{
6719 (*pMyDisasm).Instruction.Category = GENERAL_PURPOSE_INSTRUCTION+DATA_TRANSFER;
6720 #ifndef BEA_LIGHT_DISASSEMBLY
6721 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mov ");
6722 #endif
6723 GV.MemDecoration = Arg2word;
6724 GV.OperandSize = 16;
6725 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
6726 GV.OperandSize = 32;
6727 GV.SEG_ = 1;
6728 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
6729 GV.SEG_ = 0;
6730 GV.EIP_ += GV.DECALAGE_EIP+2;
6731}
Note: See TracBrowser for help on using the repository browser.