source: Daodan/src/beaengine/Includes/instr_set/opcodes_SSE.c@ 1163

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

Daodan: TV code
File size: 159.0 KB
RevLine 
[984]1/* Copyright 2006-2009, BeatriX
2 * File coded by BeatriX
3 *
4 * This file is part of BeaEngine.
5 *
6 * BeaEngine is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU Lesser General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * BeaEngine is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with BeaEngine. If not, see <http://www.gnu.org/licenses/>. */
18
19/* ====================================================================
20 * 0x 0f 58
21 * ==================================================================== */
22void __bea_callspec__ addps_VW(PDISASM pMyDisasm)
23{
24 /* ========= 0xf2 */
25 if (GV.PrefRepne == 1) {
26 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
27 GV.MemDecoration = Arg2qword;
28 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
29 #ifndef BEA_LIGHT_DISASSEMBLY
30 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addsd ");
31 #endif
32 GV.SSE_ = 1;
33 GxEx(pMyDisasm);
34 GV.SSE_ = 0;
35 }
36 /* ========= 0xf3 */
37 else if (GV.PrefRepe == 1) {
38 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
39 GV.MemDecoration = Arg2dword;
40 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
41 #ifndef BEA_LIGHT_DISASSEMBLY
42 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addss ");
43 #endif
44 GV.SSE_ = 1;
45 GxEx(pMyDisasm);
46 GV.SSE_ = 0;
47 }
48 /* ========== 0x66 */
49 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
50 GV.OperandSize = GV.OriginalOperandSize;
51 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
52 GV.MemDecoration = Arg2dqword;
53 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
54 #ifndef BEA_LIGHT_DISASSEMBLY
55 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addpd ");
56 #endif
57 GV.SSE_ = 1;
58 GxEx(pMyDisasm);
59 GV.SSE_ = 0;
60 }
61 else {
62 GV.MemDecoration = Arg2dqword;
63 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
64 #ifndef BEA_LIGHT_DISASSEMBLY
65 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addps ");
66 #endif
67 GV.SSE_ = 1;
68 GxEx(pMyDisasm);
69 GV.SSE_ = 0;
70 }
71}
72
73/* ====================================================================
74 * 0x 0f d0
75 * ==================================================================== */
76void __bea_callspec__ addsubpd_(PDISASM pMyDisasm)
77{
78 /* ========= 0xf2 */
79 if (GV.PrefRepne == 1) {
80 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
81 GV.MemDecoration = Arg2dqword;
82 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_PACKED;
83 #ifndef BEA_LIGHT_DISASSEMBLY
84 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addsubps ");
85 #endif
86 GV.SSE_ = 1;
87 GxEx(pMyDisasm);
88 GV.SSE_ = 0;
89 }
90
91 /* ========== 0x66 */
92 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
93 GV.OperandSize = GV.OriginalOperandSize;
94 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
95 GV.MemDecoration = Arg2dqword;
96 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_PACKED;
97 #ifndef BEA_LIGHT_DISASSEMBLY
98 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "addsubpd ");
99 #endif
100 GV.SSE_ = 1;
101 GxEx(pMyDisasm);
102 GV.SSE_ = 0;
103 }
104 else {
105 FailDecode(pMyDisasm);
106 }
107}
108
109
110/* ====================================================================
111 * 0x 0f 55
112 * ==================================================================== */
113void __bea_callspec__ andnps_VW(PDISASM pMyDisasm)
114{
115 /* ========== 0x66 */
116 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
117 GV.OperandSize = GV.OriginalOperandSize;
118 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
119 GV.MemDecoration = Arg2dqword;
120 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
121 #ifndef BEA_LIGHT_DISASSEMBLY
122 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andnpd ");
123 #endif
124 GV.SSE_ = 1;
125 GxEx(pMyDisasm);
126 GV.SSE_ = 0;
127 }
128 else {
129 GV.MemDecoration = Arg2dqword;
130 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
131 #ifndef BEA_LIGHT_DISASSEMBLY
132 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andnps ");
133 #endif
134 GV.SSE_ = 1;
135 GxEx(pMyDisasm);
136 GV.SSE_ = 0;
137 }
138}
139
140
141/* ====================================================================
142 * 0x 0f 54
143 * ==================================================================== */
144void __bea_callspec__ andps_VW(PDISASM pMyDisasm)
145{
146 /* ========== 0x66 */
147 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
148 GV.OperandSize = GV.OriginalOperandSize;
149 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
150 GV.MemDecoration = Arg2dqword;
151 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
152 #ifndef BEA_LIGHT_DISASSEMBLY
153 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andpd ");
154 #endif
155 GV.SSE_ = 1;
156 GxEx(pMyDisasm);
157 GV.SSE_ = 0;
158 }
159 else {
160 GV.MemDecoration = Arg2dqword;
161 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
162 #ifndef BEA_LIGHT_DISASSEMBLY
163 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "andps ");
164 #endif
165 GV.SSE_ = 1;
166 GxEx(pMyDisasm);
167 GV.SSE_ = 0;
168 }
169}
170
171
172/* ====================================================================
173 * 0x 0f 3a 0d
174 * ==================================================================== */
175void __bea_callspec__ blendpd_(PDISASM pMyDisasm)
176{
177 /* ========== 0x66 */
178 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
179 GV.OperandSize = GV.OriginalOperandSize;
180 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
181 GV.MemDecoration = Arg2dqword;
182 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_BLENDING_INSTRUCTION;
183 #ifndef BEA_LIGHT_DISASSEMBLY
184 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "blendpd ");
185 #endif
186 GV.ImmediatSize = 8;
187 GV.SSE_ = 1;
188 GxEx(pMyDisasm);
189 GV.SSE_ = 0;
190 GV.EIP_++;
191 if (!Security(0, pMyDisasm)) return;
192 GV.third_arg = 1;
193 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
194 #ifndef BEA_LIGHT_DISASSEMBLY
195 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
196 #endif
197 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
198 (*pMyDisasm).Argument3.ArgSize = 8;
199
200
201 }
202 else {
203 FailDecode(pMyDisasm);
204 }
205
206}
207
208
209/* ====================================================================
210 * 0x 0f 3a 0c
211 * ==================================================================== */
212void __bea_callspec__ blendps_(PDISASM pMyDisasm)
213{
214 /* ========== 0x66 */
215 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
216 GV.OperandSize = GV.OriginalOperandSize;
217 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
218 GV.MemDecoration = Arg2dqword;
219 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_BLENDING_INSTRUCTION;
220 #ifndef BEA_LIGHT_DISASSEMBLY
221 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "blendps ");
222 #endif
223 GV.ImmediatSize = 8;
224 GV.SSE_ = 1;
225 GxEx(pMyDisasm);
226 GV.SSE_ = 0;
227 GV.EIP_++;
228 if (!Security(0, pMyDisasm)) return;
229 GV.third_arg = 1;
230 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
231 #ifndef BEA_LIGHT_DISASSEMBLY
232 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
233 #endif
234 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
235 (*pMyDisasm).Argument3.ArgSize = 8;
236
237 }
238 else {
239 FailDecode(pMyDisasm);
240 }
241}
242
243
244/* ====================================================================
245 * 0x 0f 38 15
246 * ==================================================================== */
247void __bea_callspec__ blendvpd_(PDISASM pMyDisasm)
248{
249 /* ========== 0x66 */
250 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
251 GV.OperandSize = GV.OriginalOperandSize;
252 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
253 GV.MemDecoration = Arg2dqword;
254 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_BLENDING_INSTRUCTION;
255 #ifndef BEA_LIGHT_DISASSEMBLY
256 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "blendvpd ");
257 #endif
258 GV.SSE_ = 1;
259 GxEx(pMyDisasm);
260 GV.SSE_ = 0;
261 }
262 else {
263 FailDecode(pMyDisasm);
264 }
265
266}
267
268
269/* ====================================================================
270 * 0x 0f 38 14
271 * ==================================================================== */
272void __bea_callspec__ blendvps_(PDISASM pMyDisasm)
273{
274 /* ========== 0x66 */
275 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
276 GV.OperandSize = GV.OriginalOperandSize;
277 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
278 GV.MemDecoration = Arg2dqword;
279 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_BLENDING_INSTRUCTION;
280 #ifndef BEA_LIGHT_DISASSEMBLY
281 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "blendvps ");
282 #endif
283 GV.SSE_ = 1;
284 GxEx(pMyDisasm);
285 GV.SSE_ = 0;
286 }
287 else {
288 FailDecode(pMyDisasm);
289 }
290}
291
292
293/* ====================================================================
294 * 0x 0f c2
295 * ==================================================================== */
296void __bea_callspec__ cmpps_VW(PDISASM pMyDisasm)
297{
298
299 /* ========= 0xf2 */
300 GV.ImmediatSize = 8;
301 if (GV.PrefRepne == 1) {
302 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
303 GV.MemDecoration = Arg2qword;
304 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
305 #ifndef BEA_LIGHT_DISASSEMBLY
306 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpsd ");
307 #endif
308 GV.SSE_ = 1;
309 GxEx(pMyDisasm);
310 GV.SSE_ = 0;
311 }
312 /* ========== 0xf3 */
313 else if (GV.PrefRepe == 1) {
314 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
315 GV.MemDecoration = Arg2dword;
316 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
317 #ifndef BEA_LIGHT_DISASSEMBLY
318 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpss ");
319 #endif
320 GV.SSE_ = 1;
321 GxEx(pMyDisasm);
322 GV.SSE_ = 0;
323 }
324 /* ========== 0x66 */
325 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
326 GV.OperandSize = GV.OriginalOperandSize;
327 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
328 GV.MemDecoration = Arg2dqword;
329 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
330 #ifndef BEA_LIGHT_DISASSEMBLY
331 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmppd ");
332 #endif
333 GV.SSE_ = 1;
334 GxEx(pMyDisasm);
335 GV.SSE_ = 0;
336 }
337 else {
338 GV.MemDecoration = Arg2dqword;
339 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
340 #ifndef BEA_LIGHT_DISASSEMBLY
341 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cmpps ");
342 #endif
343 GV.SSE_ = 1;
344 GxEx(pMyDisasm);
345 GV.SSE_ = 0;
346 }
347 (*pMyDisasm).Argument1.AccessMode = READ;
348 GV.EIP_++;
349 if (!Security(0, pMyDisasm)) return;
350 GV.third_arg = 1;
351 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
352 #ifndef BEA_LIGHT_DISASSEMBLY
353 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
354 #endif
355 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
356 (*pMyDisasm).Argument3.ArgSize = 8;
357
358}
359
360
361/* ====================================================================
362 * 0x 0f 38 f0
363 * ==================================================================== */
364void __bea_callspec__ crc32_GvEb(PDISASM pMyDisasm)
365{
366 /* ========= 0xf2 */
367 if (GV.PrefRepne == 1) {
368 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
369 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+ACCELERATOR_INSTRUCTION;
370 #ifndef BEA_LIGHT_DISASSEMBLY
371 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "crc32 ");
372 #endif
373 if (GV.OperandSize == 64) {
374 GV.MemDecoration = Arg2byte;
375 GV.OperandSize = 8;
376 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
377 GV.OperandSize = 64;
378 }
379 else if (GV.OperandSize == 32) {
380 GV.MemDecoration = Arg2byte;
381 GV.OperandSize = 8;
382 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
383 GV.OperandSize = 32;
384 }
385 else {
386 GV.MemDecoration = Arg2byte;
387 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
388 }
389
390 if (GV.OperandSize == 16) {
391 GV.OperandSize = 32;
392 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
393 GV.OperandSize = 16;
394 }
395 else {
396 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
397 }
398 GV.EIP_ += GV.DECALAGE_EIP+2;
399 }
400 else {
401 FailDecode(pMyDisasm);
402 }
403}
404
405/* ====================================================================
406 * 0x 0f 38 f1
407 * ==================================================================== */
408void __bea_callspec__ crc32_GvEv(PDISASM pMyDisasm)
409{
410 /* ========= 0xf2 */
411 if (GV.PrefRepne == 1) {
412 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
413 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+ACCELERATOR_INSTRUCTION;
414 #ifndef BEA_LIGHT_DISASSEMBLY
415 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "crc32 ");
416 #endif
417
418 if (GV.OperandSize == 64) {
419 GV.MemDecoration = Arg2qword;
420 }
421 else if (GV.OperandSize == 32) {
422 GV.MemDecoration = Arg2dword;
423 }
424 else {
425 GV.MemDecoration = Arg2word;
426 }
427 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
428
429 if (GV.OperandSize == 16) {
430 GV.OperandSize = 32;
431 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
432 GV.OperandSize = 16;
433 }
434 else {
435 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
436 }
437 GV.EIP_ += GV.DECALAGE_EIP+2;
438 }
439 else {
440 FailDecode(pMyDisasm);
441 }
442}
443
444
445/* ====================================================================
446 * 0x 0f 2f
447 * ==================================================================== */
448void __bea_callspec__ comiss_VW(PDISASM pMyDisasm)
449{
450 /* ========== 0x66 */
451 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
452 GV.OperandSize = GV.OriginalOperandSize;
453 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
454 GV.MemDecoration = Arg2qword;
455 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
456 #ifndef BEA_LIGHT_DISASSEMBLY
457 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "comisd ");
458 #endif
459 GV.SSE_ = 1;
460 GxEx(pMyDisasm);
461 GV.SSE_ = 0;
462 }
463 else {
464 GV.MemDecoration = Arg2dqword;
465 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
466 #ifndef BEA_LIGHT_DISASSEMBLY
467 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "comiss ");
468 #endif
469 GV.SSE_ = 1;
470 GxEx(pMyDisasm);
471 GV.SSE_ = 0;
472 }
473}
474
475/* ====================================================================
476 * 0x 0f 5a
477 * ==================================================================== */
478void __bea_callspec__ cvtps2pd_(PDISASM pMyDisasm)
479{
480 /* ========= 0xf2 */
481 if (GV.PrefRepne == 1) {
482 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
483 GV.MemDecoration = Arg2qword;
484 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
485 #ifndef BEA_LIGHT_DISASSEMBLY
486 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtsd2ss ");
487 #endif
488 GV.SSE_ = 1;
489 GxEx(pMyDisasm);
490 GV.SSE_ = 0;
491 }
492 /* ========== 0xf3 */
493 else if (GV.PrefRepe == 1) {
494 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
495 GV.MemDecoration = Arg2dword;
496 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
497 #ifndef BEA_LIGHT_DISASSEMBLY
498 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtss2sd ");
499 #endif
500 GV.SSE_ = 1;
501 GxEx(pMyDisasm);
502 GV.SSE_ = 0;
503 }
504 /* ========== 0x66 */
505 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
506 GV.OperandSize = GV.OriginalOperandSize;
507 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
508 GV.MemDecoration = Arg2dqword;
509 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
510 #ifndef BEA_LIGHT_DISASSEMBLY
511 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtpd2ps ");
512 #endif
513 GV.SSE_ = 1;
514 GxEx(pMyDisasm);
515 GV.SSE_ = 0;
516 }
517 else {
518 GV.MemDecoration = Arg2qword;
519 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
520 #ifndef BEA_LIGHT_DISASSEMBLY
521 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtps2pd ");
522 #endif
523 GV.SSE_ = 1;
524 GxEx(pMyDisasm);
525 GV.SSE_ = 0;
526 }
527}
528
529
530/* ====================================================================
531 * 0x 0f 5b
532 * ==================================================================== */
533void __bea_callspec__ cvtdq2ps_(PDISASM pMyDisasm)
534{
535 /* ========== 0xf3 */
536 if (GV.PrefRepe == 1) {
537 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
538 GV.MemDecoration = Arg2dqword;
539 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
540 #ifndef BEA_LIGHT_DISASSEMBLY
541 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttps2dq ");
542 #endif
543 GV.SSE_ = 1;
544 GxEx(pMyDisasm);
545 GV.SSE_ = 0;
546 }
547 /* ========== 0x66 */
548 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
549 GV.OperandSize = GV.OriginalOperandSize;
550 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
551 GV.MemDecoration = Arg2dqword;
552 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
553 #ifndef BEA_LIGHT_DISASSEMBLY
554 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtps2dq ");
555 #endif
556 GV.SSE_ = 1;
557 GxEx(pMyDisasm);
558 GV.SSE_ = 0;
559 }
560 else {
561 GV.MemDecoration = Arg2dqword;
562 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
563 #ifndef BEA_LIGHT_DISASSEMBLY
564 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtdq2ps ");
565 #endif
566 GV.SSE_ = 1;
567 GxEx(pMyDisasm);
568 GV.SSE_ = 0;
569 }
570}
571
572
573/* ====================================================================
574 * 0x 0f 2a
575 * ==================================================================== */
576void __bea_callspec__ cvtpi2ps_(PDISASM pMyDisasm)
577{
578 /* ========= 0xf2 */
579 if (GV.PrefRepne == 1) {
580 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
581 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
582 #ifndef BEA_LIGHT_DISASSEMBLY
583 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtsi2sd ");
584 #endif
585 if (GV.REX.W_ == 1) {
586 GV.MemDecoration = Arg2qword;
587 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
588 GV.SSE_ = 1;
589 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
590 GV.SSE_ = 0;
591 GV.EIP_+= GV.DECALAGE_EIP+2;
592 }
593 else {
594 GV.MemDecoration = Arg2dword;
595 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
596 GV.SSE_ = 1;
597 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
598 GV.SSE_ = 0;
599 GV.EIP_+= GV.DECALAGE_EIP+2;
600 }
601 }
602 /* ========== 0xf3 */
603 else if (GV.PrefRepe == 1) {
604 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
605 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
606 #ifndef BEA_LIGHT_DISASSEMBLY
607 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtsi2ss ");
608 #endif
609 if (GV.REX.W_ == 1) {
610 GV.MemDecoration = Arg2qword;
611 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
612 GV.SSE_ = 1;
613 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
614 GV.SSE_ = 0;
615 GV.EIP_+= GV.DECALAGE_EIP+2;
616 }
617 else {
618 GV.MemDecoration = Arg2dword;
619 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
620 GV.SSE_ = 1;
621 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
622 GV.SSE_ = 0;
623 GV.EIP_+= GV.DECALAGE_EIP+2;
624 }
625 }
626 /* ========== 0x66 */
627 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
628 GV.OperandSize = GV.OriginalOperandSize;
629 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
630 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
631 #ifndef BEA_LIGHT_DISASSEMBLY
632 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtpi2pd ");
633 #endif
634 GV.MemDecoration = Arg2qword;
635 GV.MMX_ = 1;
636 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
637 GV.MMX_ = 0;
638 GV.SSE_ = 1;
639 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
640 GV.SSE_ = 0;
641 GV.EIP_+= GV.DECALAGE_EIP+2;
642 }
643 else {
644 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
645 #ifndef BEA_LIGHT_DISASSEMBLY
646 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtpi2ps ");
647 #endif
648 GV.MemDecoration = Arg2qword;
649 GV.MMX_ = 1;
650 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
651 GV.MMX_ = 0;
652 GV.SSE_ = 1;
653 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
654 GV.SSE_ = 0;
655 GV.EIP_+= GV.DECALAGE_EIP+2;
656 }
657}
658
659
660/* ====================================================================
661 * 0x 0f 2d
662 * ==================================================================== */
663void __bea_callspec__ cvtps2pi_(PDISASM pMyDisasm)
664{
665 /* ========= 0xf2 */
666 if (GV.PrefRepne == 1) {
667 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
668 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
669 #ifndef BEA_LIGHT_DISASSEMBLY
670 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtsd2si ");
671 #endif
672 if (GV.REX.W_ == 1) {
673 GV.MemDecoration = Arg2qword;
674 GV.SSE_ = 1;
675 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
676 GV.SSE_ = 0;
677 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
678 GV.EIP_+= GV.DECALAGE_EIP+2;
679 }
680 else {
681 GV.MemDecoration = Arg2qword;
682 GV.SSE_ = 1;
683 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
684 GV.SSE_ = 0;
685 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
686 GV.EIP_+= GV.DECALAGE_EIP+2;
687 }
688 }
689 /* ========== 0xf3 */
690 else if (GV.PrefRepe == 1) {
691 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
692 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
693 #ifndef BEA_LIGHT_DISASSEMBLY
694 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtss2si ");
695 #endif
696 if (GV.REX.W_ == 1) {
697 GV.MemDecoration = Arg2dword;
698 GV.SSE_ = 1;
699 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
700 GV.SSE_ = 0;
701 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
702 GV.EIP_+= GV.DECALAGE_EIP+2;
703 }
704 else {
705 GV.MemDecoration = Arg2dword;
706 GV.SSE_ = 1;
707 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
708 GV.SSE_ = 0;
709 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
710 GV.EIP_+= GV.DECALAGE_EIP+2;
711 }
712 }
713 /* ========== 0x66 */
714 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
715 GV.OperandSize = GV.OriginalOperandSize;
716 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
717 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
718 #ifndef BEA_LIGHT_DISASSEMBLY
719 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtpd2pi ");
720 #endif
721 GV.MemDecoration = Arg2dqword;
722 GV.SSE_ = 1;
723 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
724 GV.SSE_ = 0;
725 GV.MMX_ = 1;
726 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
727 GV.MMX_ = 0;
728 GV.EIP_+= GV.DECALAGE_EIP+2;
729 }
730 else {
731 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
732 #ifndef BEA_LIGHT_DISASSEMBLY
733 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtps2pi ");
734 #endif
735 GV.MemDecoration = Arg2qword;
736 GV.SSE_ = 1;
737 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
738 GV.SSE_ = 0;
739 GV.MMX_ = 1;
740 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
741 GV.MMX_ = 0;
742 GV.EIP_+= GV.DECALAGE_EIP+2;
743 }
744}
745
746
747/* ====================================================================
748 * 0x 0f 2c
749 * ==================================================================== */
750void __bea_callspec__ cvttps2pi_(PDISASM pMyDisasm)
751{
752 /* ========= 0xf2 */
753 if (GV.PrefRepne == 1) {
754 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
755 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
756 #ifndef BEA_LIGHT_DISASSEMBLY
757 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttsd2si ");
758 #endif
759 if (GV.REX.W_ == 1) {
760 GV.MemDecoration = Arg2qword;
761 GV.SSE_ = 1;
762 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
763 GV.SSE_ = 0;
764 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
765 GV.EIP_+= GV.DECALAGE_EIP+2;
766 }
767 else {
768 GV.MemDecoration = Arg2qword;
769 GV.SSE_ = 1;
770 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
771 GV.SSE_ = 0;
772 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
773 GV.EIP_+= GV.DECALAGE_EIP+2;
774 }
775 }
776 /* ========== 0xf3 */
777 else if (GV.PrefRepe == 1) {
778 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
779 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
780 #ifndef BEA_LIGHT_DISASSEMBLY
781 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttss2si ");
782 #endif
783 GV.MemDecoration = Arg2dword;
784 GV.SSE_ = 1;
785 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
786 GV.SSE_ = 0;
787 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
788 GV.EIP_+= GV.DECALAGE_EIP+2;
789 }
790 /* ========== 0x66 */
791 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
792 GV.OperandSize = GV.OriginalOperandSize;
793 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
794 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
795 #ifndef BEA_LIGHT_DISASSEMBLY
796 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttpd2pi ");
797 #endif
798 GV.MemDecoration = Arg2dqword;
799 GV.SSE_ = 1;
800 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
801 GV.SSE_ = 0;
802 GV.MMX_ = 1;
803 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
804 GV.MMX_ = 0;
805 GV.EIP_+= GV.DECALAGE_EIP+2;
806 }
807 else {
808 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
809 #ifndef BEA_LIGHT_DISASSEMBLY
810 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttps2pi ");
811 #endif
812 GV.MemDecoration = Arg2qword;
813 GV.SSE_ = 1;
814 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
815 GV.SSE_ = 0;
816 GV.MMX_ = 1;
817 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
818 GV.MMX_ = 0;
819 GV.EIP_+= GV.DECALAGE_EIP+2;
820 }
821}
822
823
824/* ====================================================================
825 * 0x 0f e6
826 * ==================================================================== */
827void __bea_callspec__ cvtpd2dq_(PDISASM pMyDisasm)
828{
829 /* ========== 0xf2 */
830 if (GV.PrefRepne == 1) {
831 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
832 GV.MemDecoration = Arg2dqword;
833 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
834 #ifndef BEA_LIGHT_DISASSEMBLY
835 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtpd2dq ");
836 #endif
837 GV.SSE_ = 1;
838 GxEx(pMyDisasm);
839 GV.SSE_ = 0;
840 }
841 /* ========== 0xf3 */
842 else if (GV.PrefRepe == 1) {
843 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
844 GV.MemDecoration = Arg2qword;
845 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
846 #ifndef BEA_LIGHT_DISASSEMBLY
847 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvtdq2pd ");
848 #endif
849 GV.SSE_ = 1;
850 GxEx(pMyDisasm);
851 GV.SSE_ = 0;
852 }
853 /* ========== 0x66 */
854 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
855 GV.OperandSize = GV.OriginalOperandSize;
856 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
857 GV.MemDecoration = Arg2dqword;
858 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CONVERSION_INSTRUCTION;
859 #ifndef BEA_LIGHT_DISASSEMBLY
860 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "cvttpd2dq ");
861 #endif
862 GV.SSE_ = 1;
863 GxEx(pMyDisasm);
864 GV.SSE_ = 0;
865 }
866 else {
867 FailDecode(pMyDisasm);
868 }
869}
870
871
872/* ====================================================================
873 * 0x 0f 3a 41
874 * ==================================================================== */
875void __bea_callspec__ dppd_(PDISASM pMyDisasm)
876{
877 /* ========== 0x66 */
878 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
879 GV.OperandSize = GV.OriginalOperandSize;
880 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
881 GV.MemDecoration = Arg2dqword;
882 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+DOT_PRODUCT;
883 #ifndef BEA_LIGHT_DISASSEMBLY
884 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dppd ");
885 #endif
886 GV.ImmediatSize = 8;
887 GV.SSE_ = 1;
888 GxEx(pMyDisasm);
889 GV.SSE_ = 0;
890 GV.EIP_++;
891 if (!Security(0, pMyDisasm)) return;
892 GV.third_arg = 1;
893 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
894 #ifndef BEA_LIGHT_DISASSEMBLY
895 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
896 #endif
897 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
898 (*pMyDisasm).Argument3.ArgSize = 8;
899
900
901 }
902 else {
903 FailDecode(pMyDisasm);
904 }
905
906}
907
908/* ====================================================================
909 * 0x 0f 3a 40
910 * ==================================================================== */
911void __bea_callspec__ dpps_(PDISASM pMyDisasm)
912{
913 /* ========== 0x66 */
914 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
915 GV.OperandSize = GV.OriginalOperandSize;
916 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
917 GV.MemDecoration = Arg2dqword;
918 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+DOT_PRODUCT;
919 #ifndef BEA_LIGHT_DISASSEMBLY
920 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "dpps ");
921 #endif
922 GV.ImmediatSize = 8;
923 GV.SSE_ = 1;
924 GxEx(pMyDisasm);
925 GV.SSE_ = 0;
926 GV.EIP_++;
927 if (!Security(0, pMyDisasm)) return;
928 GV.third_arg = 1;
929 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
930 #ifndef BEA_LIGHT_DISASSEMBLY
931 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
932 #endif
933 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
934 (*pMyDisasm).Argument3.ArgSize = 8;
935
936
937 }
938 else {
939 FailDecode(pMyDisasm);
940 }
941
942}
943
944
945/* ====================================================================
946 * 0x 0f 5e
947 * ==================================================================== */
948void __bea_callspec__ divps_VW(PDISASM pMyDisasm)
949{
950 /* ========= 0xf2 */
951 if (GV.PrefRepne == 1) {
952 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
953 GV.MemDecoration = Arg2qword;
954 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
955 #ifndef BEA_LIGHT_DISASSEMBLY
956 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "divsd ");
957 #endif
958 GV.SSE_ = 1;
959 GxEx(pMyDisasm);
960 GV.SSE_ = 0;
961 }
962 /* ========= 0xf3 */
963 else if (GV.PrefRepe == 1) {
964 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
965 GV.MemDecoration = Arg2dword;
966 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
967 #ifndef BEA_LIGHT_DISASSEMBLY
968 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "divss ");
969 #endif
970 GV.SSE_ = 1;
971 GxEx(pMyDisasm);
972 GV.SSE_ = 0;
973 }
974 /* ========== 0x66 */
975 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
976 GV.OperandSize = GV.OriginalOperandSize;
977 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
978 GV.MemDecoration = Arg2dqword;
979 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
980 #ifndef BEA_LIGHT_DISASSEMBLY
981 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "divpd ");
982 #endif
983 GV.SSE_ = 1;
984 GxEx(pMyDisasm);
985 GV.SSE_ = 0;
986 }
987 else {
988 GV.MemDecoration = Arg2dqword;
989 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
990 #ifndef BEA_LIGHT_DISASSEMBLY
991 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "divps ");
992 #endif
993 GV.SSE_ = 1;
994 GxEx(pMyDisasm);
995 GV.SSE_ = 0;
996 }
997}
998
999
1000/* ====================================================================
1001 * 0x 0f 3a 17
1002 * ==================================================================== */
1003void __bea_callspec__ extractps_(PDISASM pMyDisasm)
1004{
1005 /* ========== 0x66 */
1006 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1007 GV.OperandSize = GV.OriginalOperandSize;
1008 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1009 GV.MemDecoration = Arg1dword;
1010 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
1011 #ifndef BEA_LIGHT_DISASSEMBLY
1012 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "extractps ");
1013 #endif
1014 GV.ImmediatSize = 8;
1015 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
1016 GV.SSE_ = 1;
1017 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
1018 GV.SSE_ = 0;
1019 GV.EIP_+= GV.DECALAGE_EIP+2;
1020 GV.EIP_++;
1021 if (!Security(0, pMyDisasm)) return;
1022 GV.third_arg = 1;
1023 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
1024 #ifndef BEA_LIGHT_DISASSEMBLY
1025 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
1026 #endif
1027 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1028 (*pMyDisasm).Argument3.ArgSize = 8;
1029
1030
1031 }
1032 else {
1033 FailDecode(pMyDisasm);
1034 }
1035
1036}
1037
1038
1039/* ====================================================================
1040 * 0x 0f 7c
1041 * ==================================================================== */
1042void __bea_callspec__ haddpd_VW(PDISASM pMyDisasm)
1043{
1044
1045 /* ========== 0x66 */
1046 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1047 GV.OperandSize = GV.OriginalOperandSize;
1048 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1049 GV.MemDecoration = Arg2dqword;
1050 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
1051 #ifndef BEA_LIGHT_DISASSEMBLY
1052 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "haddpd ");
1053 #endif
1054 GV.SSE_ = 1;
1055 GxEx(pMyDisasm);
1056 GV.SSE_ = 0;
1057 }
1058 else {
1059 GV.MemDecoration = Arg2dqword;
1060 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
1061 #ifndef BEA_LIGHT_DISASSEMBLY
1062 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "haddps ");
1063 #endif
1064 GV.SSE_ = 1;
1065 GxEx(pMyDisasm);
1066 GV.SSE_ = 0;
1067 }
1068}
1069
1070
1071/* ====================================================================
1072 * 0x 0f 7d
1073 * ==================================================================== */
1074void __bea_callspec__ hsubpd_VW(PDISASM pMyDisasm)
1075{
1076
1077 /* ========== 0x66 */
1078 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1079 GV.OperandSize = GV.OriginalOperandSize;
1080 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1081 GV.MemDecoration = Arg2dqword;
1082 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
1083 #ifndef BEA_LIGHT_DISASSEMBLY
1084 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hsubpd ");
1085 #endif
1086 GV.SSE_ = 1;
1087 GxEx(pMyDisasm);
1088 GV.SSE_ = 0;
1089 }
1090 else {
1091 GV.MemDecoration = Arg2dqword;
1092 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SIMD_FP_HORIZONTAL;
1093 #ifndef BEA_LIGHT_DISASSEMBLY
1094 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "hsubps ");
1095 #endif
1096 GV.SSE_ = 1;
1097 GxEx(pMyDisasm);
1098 GV.SSE_ = 0;
1099 }
1100}
1101
1102
1103/* ====================================================================
1104 * 0x 0f 3a 21
1105 * ==================================================================== */
1106void __bea_callspec__ insertps_(PDISASM pMyDisasm)
1107{
1108 /* ========== 0x66 */
1109 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1110 GV.OperandSize = GV.OriginalOperandSize;
1111 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1112 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
1113 #ifndef BEA_LIGHT_DISASSEMBLY
1114 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "insertps ");
1115 #endif
1116 GV.SSE_ = 1;
1117 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
1118 if (GV.MOD_== 0x3) {
1119 GV.MemDecoration = Arg2qword;
1120 }
1121 else {
1122 GV.MemDecoration = Arg2dword;
1123 }
1124
1125 GV.ImmediatSize = 8;
1126 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
1127
1128
1129 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
1130 GV.SSE_ = 0;
1131 GV.EIP_+= GV.DECALAGE_EIP+2;
1132 GV.EIP_++;
1133 if (!Security(0, pMyDisasm)) return;
1134 GV.third_arg = 1;
1135 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
1136 #ifndef BEA_LIGHT_DISASSEMBLY
1137 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
1138 #endif
1139 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1140 (*pMyDisasm).Argument3.ArgSize = 8;
1141
1142
1143 }
1144 else {
1145 FailDecode(pMyDisasm);
1146 }
1147
1148}
1149
1150
1151
1152/* ====================================================================
1153 * 0x 0f f0
1154 * ==================================================================== */
1155void __bea_callspec__ lddqu_(PDISASM pMyDisasm)
1156{
1157 /* ========= 0xf2 */
1158 if (GV.PrefRepne == 1) {
1159 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1160 GV.MemDecoration = Arg2dqword;
1161 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+SPECIALIZED_128bits;
1162 #ifndef BEA_LIGHT_DISASSEMBLY
1163 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "lddqu ");
1164 #endif
1165 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
1166 GV.SSE_ = 1;
1167 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
1168 GV.SSE_ = 0;
1169 GV.EIP_+= GV.DECALAGE_EIP+2;
1170 }
1171 else {
1172 FailDecode(pMyDisasm);
1173 }
1174
1175}
1176
1177
1178/* ====================================================================
1179 * 0x 0f f7
1180 * ==================================================================== */
1181void __bea_callspec__ maskmovq_(PDISASM pMyDisasm)
1182{
1183 /* ========== 0x66 */
1184 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1185 GV.OperandSize = GV.OriginalOperandSize;
1186 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1187 GV.MemDecoration = Arg2dqword;
1188 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
1189 #ifndef BEA_LIGHT_DISASSEMBLY
1190 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maskmovdqu ");
1191 #endif
1192 GV.SSE_ = 1;
1193 GxEx(pMyDisasm);
1194 GV.SSE_ = 0;
1195 }
1196 else {
1197 GV.MemDecoration = Arg2qword;
1198 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+CACHEABILITY_CONTROL;
1199 #ifndef BEA_LIGHT_DISASSEMBLY
1200 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maskmovq ");
1201 #endif
1202 GV.MMX_ = 1;
1203 GxEx(pMyDisasm);
1204 GV.MMX_ = 0;
1205 }
1206}
1207
1208
1209/* ====================================================================
1210 * 0x 0f 5f
1211 * ==================================================================== */
1212void __bea_callspec__ maxps_VW(PDISASM pMyDisasm)
1213{
1214 /* ========= 0xf2 */
1215 if (GV.PrefRepne == 1) {
1216 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1217 GV.MemDecoration = Arg2qword;
1218 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1219 #ifndef BEA_LIGHT_DISASSEMBLY
1220 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maxsd ");
1221 #endif
1222 GV.SSE_ = 1;
1223 GxEx(pMyDisasm);
1224 GV.SSE_ = 0;
1225 }
1226 /* ========= 0xf3 */
1227 else if (GV.PrefRepe == 1) {
1228 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1229 GV.MemDecoration = Arg2dword;
1230 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1231 #ifndef BEA_LIGHT_DISASSEMBLY
1232 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maxss ");
1233 #endif
1234 GV.SSE_ = 1;
1235 GxEx(pMyDisasm);
1236 GV.SSE_ = 0;
1237 }
1238 /* ========== 0x66 */
1239 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1240 GV.OperandSize = GV.OriginalOperandSize;
1241 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1242 GV.MemDecoration = Arg2dqword;
1243 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1244 #ifndef BEA_LIGHT_DISASSEMBLY
1245 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maxpd ");
1246 #endif
1247 GV.SSE_ = 1;
1248 GxEx(pMyDisasm);
1249 GV.SSE_ = 0;
1250 }
1251 else {
1252 GV.MemDecoration = Arg2dqword;
1253 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1254 #ifndef BEA_LIGHT_DISASSEMBLY
1255 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "maxps ");
1256 #endif
1257 GV.SSE_ = 1;
1258 GxEx(pMyDisasm);
1259 GV.SSE_ = 0;
1260 }
1261}
1262
1263
1264/* ====================================================================
1265 * 0x 0f 5d
1266 * ==================================================================== */
1267void __bea_callspec__ minps_VW(PDISASM pMyDisasm)
1268{
1269 /* ========= 0xf2 */
1270 if (GV.PrefRepne == 1) {
1271 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1272 GV.MemDecoration = Arg2qword;
1273 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1274 #ifndef BEA_LIGHT_DISASSEMBLY
1275 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "minsd ");
1276 #endif
1277 GV.SSE_ = 1;
1278 GxEx(pMyDisasm);
1279 GV.SSE_ = 0;
1280 }
1281 /* ========= 0xf3 */
1282 else if (GV.PrefRepe == 1) {
1283 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1284 GV.MemDecoration = Arg2dword;
1285 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1286 #ifndef BEA_LIGHT_DISASSEMBLY
1287 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "minss ");
1288 #endif
1289 GV.SSE_ = 1;
1290 GxEx(pMyDisasm);
1291 GV.SSE_ = 0;
1292 }
1293 /* ========== 0x66 */
1294 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1295 GV.OperandSize = GV.OriginalOperandSize;
1296 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1297 GV.MemDecoration = Arg2dqword;
1298 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1299 #ifndef BEA_LIGHT_DISASSEMBLY
1300 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "minpd ");
1301 #endif
1302 GV.SSE_ = 1;
1303 GxEx(pMyDisasm);
1304 GV.SSE_ = 0;
1305 }
1306 else {
1307 GV.MemDecoration = Arg2dqword;
1308 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1309 #ifndef BEA_LIGHT_DISASSEMBLY
1310 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "minps ");
1311 #endif
1312 GV.SSE_ = 1;
1313 GxEx(pMyDisasm);
1314 GV.SSE_ = 0;
1315 }
1316}
1317
1318/* ====================================================================
1319 * 0x 0f 28
1320 * ==================================================================== */
1321void __bea_callspec__ movaps_VW(PDISASM pMyDisasm)
1322{
1323 /* ========== 0x66 */
1324 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1325 GV.OperandSize = GV.OriginalOperandSize;
1326 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1327 GV.MemDecoration = Arg2dqword;
1328 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1329 #ifndef BEA_LIGHT_DISASSEMBLY
1330 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movapd ");
1331 #endif
1332 GV.SSE_ = 1;
1333 GxEx(pMyDisasm);
1334 GV.SSE_ = 0;
1335 }
1336 else {
1337 GV.MemDecoration = Arg2dqword;
1338 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1339 #ifndef BEA_LIGHT_DISASSEMBLY
1340 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movaps ");
1341 #endif
1342 GV.SSE_ = 1;
1343 GxEx(pMyDisasm);
1344 GV.SSE_ = 0;
1345 }
1346}
1347
1348/* ====================================================================
1349 * 0x 0f 29
1350 * ==================================================================== */
1351void __bea_callspec__ movaps_WV(PDISASM pMyDisasm)
1352{
1353 /* ========== 0x66 */
1354 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1355 GV.OperandSize = GV.OriginalOperandSize;
1356 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1357 GV.MemDecoration = Arg1dqword;
1358 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1359 #ifndef BEA_LIGHT_DISASSEMBLY
1360 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movapd ");
1361 #endif
1362 GV.SSE_ = 1;
1363 ExGx(pMyDisasm);
1364 GV.SSE_ = 0;
1365 }
1366 else {
1367 GV.MemDecoration = Arg2dqword;
1368 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1369 #ifndef BEA_LIGHT_DISASSEMBLY
1370 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movaps ");
1371 #endif
1372 GV.SSE_ = 1;
1373 ExGx(pMyDisasm);
1374 GV.SSE_ = 0;
1375 }
1376}
1377
1378
1379/* ====================================================================
1380 * 0x 0f 16
1381 * ==================================================================== */
1382void __bea_callspec__ movhps_VM(PDISASM pMyDisasm)
1383{
1384
1385 /* ========= 0xf3 */
1386 if (GV.PrefRepe == 1) {
1387 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1388 GV.MemDecoration = Arg2qword;
1389 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+DATA_TRANSFER;
1390 #ifndef BEA_LIGHT_DISASSEMBLY
1391 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movshdup ");
1392 #endif
1393 GV.SSE_ = 1;
1394 GxEx(pMyDisasm);
1395 GV.SSE_ = 0;
1396 }
1397 /* ========== 0x66 */
1398 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1399 GV.OperandSize = GV.OriginalOperandSize;
1400 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1401 GV.MemDecoration = Arg2qword;
1402 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1403 #ifndef BEA_LIGHT_DISASSEMBLY
1404 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhpd ");
1405 #endif
1406 GV.SSE_ = 1;
1407 GxEx(pMyDisasm);
1408 GV.SSE_ = 0;
1409 }
1410 else {
1411 GV.MemDecoration = Arg2qword;
1412 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
1413 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
1414 if (GV.MOD_== 0x3) {
1415 #ifndef BEA_LIGHT_DISASSEMBLY
1416 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlhps ");
1417 #endif
1418 }
1419 else {
1420 #ifndef BEA_LIGHT_DISASSEMBLY
1421 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhps ");
1422 #endif
1423 }
1424 GV.SSE_ = 1;
1425 GxEx(pMyDisasm);
1426 GV.SSE_ = 0;
1427 }
1428}
1429
1430
1431/* ====================================================================
1432 * 0x 0f 17
1433 * ==================================================================== */
1434void __bea_callspec__ movhps_MV(PDISASM pMyDisasm)
1435{
1436
1437 /* ========== 0x66 */
1438 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1439 GV.OperandSize = GV.OriginalOperandSize;
1440 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1441 GV.MemDecoration = Arg1qword;
1442 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1443 #ifndef BEA_LIGHT_DISASSEMBLY
1444 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhpd ");
1445 #endif
1446 GV.SSE_ = 1;
1447 ExGx(pMyDisasm);
1448 GV.SSE_ = 0;
1449 }
1450 else {
1451 GV.MemDecoration = Arg1qword;
1452 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
1453 #ifndef BEA_LIGHT_DISASSEMBLY
1454 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhps ");
1455 #endif
1456 GV.SSE_ = 1;
1457 ExGx(pMyDisasm);
1458 GV.SSE_ = 0;
1459 }
1460}
1461
1462
1463/* ====================================================================
1464 * 0x 0f 12
1465 * ==================================================================== */
1466void __bea_callspec__ movlps_VM(PDISASM pMyDisasm)
1467{
1468 /* ========= 0xf2 */
1469 if (GV.PrefRepne == 1) {
1470 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1471 GV.MemDecoration = Arg2qword;
1472 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+DATA_TRANSFER;
1473 #ifndef BEA_LIGHT_DISASSEMBLY
1474 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movddup ");
1475 #endif
1476 GV.SSE_ = 1;
1477 GxEx(pMyDisasm);
1478 GV.SSE_ = 0;
1479 }
1480 /* ========= 0xf3 */
1481 else if (GV.PrefRepe == 1) {
1482 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1483 GV.MemDecoration = Arg2qword;
1484 (*pMyDisasm).Instruction.Category = SSE3_INSTRUCTION+DATA_TRANSFER;
1485 #ifndef BEA_LIGHT_DISASSEMBLY
1486 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsldup ");
1487 #endif
1488 GV.SSE_ = 1;
1489 GxEx(pMyDisasm);
1490 GV.SSE_ = 0;
1491 }
1492 /* ========== 0x66 */
1493 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1494 GV.OperandSize = GV.OriginalOperandSize;
1495 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1496 GV.MemDecoration = Arg2qword;
1497 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1498 #ifndef BEA_LIGHT_DISASSEMBLY
1499 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlpd ");
1500 #endif
1501 GV.SSE_ = 1;
1502 GxEx(pMyDisasm);
1503 GV.SSE_ = 0;
1504 }
1505 else {
1506 GV.MemDecoration = Arg2qword;
1507 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
1508 if (GV.MOD_== 0x3) {
1509 #ifndef BEA_LIGHT_DISASSEMBLY
1510 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movhlps ");
1511 #endif
1512 }
1513 else {
1514 #ifndef BEA_LIGHT_DISASSEMBLY
1515 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlps ");
1516 #endif
1517 }
1518 GV.SSE_ = 1;
1519 GxEx(pMyDisasm);
1520 GV.SSE_ = 0;
1521 }
1522}
1523
1524
1525/* ====================================================================
1526 * 0x 0f 13
1527 * ==================================================================== */
1528void __bea_callspec__ movlps_MV(PDISASM pMyDisasm)
1529{
1530
1531 /* ========== 0x66 */
1532 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1533 GV.OperandSize = GV.OriginalOperandSize;
1534 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1535 GV.MemDecoration = Arg1qword;
1536 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1537 #ifndef BEA_LIGHT_DISASSEMBLY
1538 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlpd ");
1539 #endif
1540 GV.SSE_ = 1;
1541 ExGx(pMyDisasm);
1542 GV.SSE_ = 0;
1543 }
1544 else {
1545 GV.MemDecoration = Arg1qword;
1546 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
1547 #ifndef BEA_LIGHT_DISASSEMBLY
1548 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movlps ");
1549 #endif
1550 GV.SSE_ = 1;
1551 ExGx(pMyDisasm);
1552 GV.SSE_ = 0;
1553 }
1554}
1555
1556
1557/* ====================================================================
1558 * 0x 0f 50
1559 * ==================================================================== */
1560void __bea_callspec__ movmskps_(PDISASM pMyDisasm)
1561{
1562 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
1563 if (GV.MOD_!= 0x3) {
1564 FailDecode(pMyDisasm);
1565 }
1566 /* ========== 0x66 */
1567 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1568 GV.OperandSize = GV.OriginalOperandSize;
1569 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1570 GV.MemDecoration = Arg2dqword;
1571 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+DATA_TRANSFER;
1572 #ifndef BEA_LIGHT_DISASSEMBLY
1573 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movmskpd ");
1574 #endif
1575 GV.SSE_ = 1;
1576 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
1577 GV.SSE_ = 0;
1578 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
1579 GV.EIP_ += GV.DECALAGE_EIP+2;
1580
1581 }
1582 else {
1583 GV.MemDecoration = Arg2dqword;
1584 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+DATA_TRANSFER;
1585 #ifndef BEA_LIGHT_DISASSEMBLY
1586 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movmskps ");
1587 #endif
1588 GV.SSE_ = 1;
1589 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
1590 GV.SSE_ = 0;
1591 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
1592 GV.EIP_ += GV.DECALAGE_EIP+2;
1593
1594 }
1595}
1596
1597
1598/* ====================================================================
1599 * 0x 0f 38 2a
1600 * ==================================================================== */
1601void __bea_callspec__ movntdqa_(PDISASM pMyDisasm)
1602{
1603
1604 /* ========== 0x66 */
1605 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1606 GV.OperandSize = GV.OriginalOperandSize;
1607 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1608 GV.MemDecoration = Arg2dqword;
1609 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+STREAMING_LOAD;
1610 #ifndef BEA_LIGHT_DISASSEMBLY
1611 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntdqa ");
1612 #endif
1613 GV.SSE_ = 1;
1614 GxEx(pMyDisasm);
1615 GV.SSE_ = 0;
1616 }
1617 else {
1618 FailDecode(pMyDisasm);
1619 }
1620}
1621
1622
1623/* ====================================================================
1624 * 0x 0f c3
1625 * ==================================================================== */
1626void __bea_callspec__ movnti_(PDISASM pMyDisasm)
1627{
1628 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
1629 #ifndef BEA_LIGHT_DISASSEMBLY
1630 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movnti ");
1631 #endif
1632 EvGv(pMyDisasm);
1633
1634}
1635
1636
1637/* ====================================================================
1638 * 0x 0f 2b
1639 * ==================================================================== */
1640void __bea_callspec__ movntps_(PDISASM pMyDisasm)
1641{
1642 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
1643 if (GV.MOD_== 0x3) {
1644 FailDecode(pMyDisasm);
1645 }
1646 /* ========== 0x66 */
1647 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1648 GV.OperandSize = GV.OriginalOperandSize;
1649 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1650 GV.MemDecoration = Arg1dqword;
1651 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
1652 #ifndef BEA_LIGHT_DISASSEMBLY
1653 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntpd ");
1654 #endif
1655 GV.SSE_ = 1;
1656 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
1657 GV.SSE_ = 0;
1658 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
1659 GV.EIP_ += GV.DECALAGE_EIP+2;
1660
1661 }
1662 else {
1663 GV.MemDecoration = Arg1dqword;
1664 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
1665 #ifndef BEA_LIGHT_DISASSEMBLY
1666 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntps ");
1667 #endif
1668 GV.SSE_ = 1;
1669 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
1670 GV.SSE_ = 0;
1671 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
1672 GV.EIP_ += GV.DECALAGE_EIP+2;
1673
1674 }
1675}
1676
1677
1678/* ====================================================================
1679 * 0x 0f e7
1680 * ==================================================================== */
1681void __bea_callspec__ movntq_(PDISASM pMyDisasm)
1682{
1683 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
1684 if (GV.MOD_== 0x3) {
1685 FailDecode(pMyDisasm);
1686 }
1687 /* ========== 0x66 */
1688 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1689 GV.OperandSize = GV.OriginalOperandSize;
1690 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1691 GV.MemDecoration = Arg1dqword;
1692 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+CACHEABILITY_CONTROL;
1693 #ifndef BEA_LIGHT_DISASSEMBLY
1694 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntdq ");
1695 #endif
1696 GV.SSE_ = 1;
1697 ExGx(pMyDisasm);
1698 GV.SSE_ = 0;
1699 }
1700 else {
1701 GV.MemDecoration = Arg1qword;
1702 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+CACHEABILITY_CONTROL;
1703 #ifndef BEA_LIGHT_DISASSEMBLY
1704 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movntq ");
1705 #endif
1706 GV.MMX_ = 1;
1707 ExGx(pMyDisasm);
1708 GV.MMX_ = 0;
1709 }
1710}
1711
1712
1713/* ====================================================================
1714 * 0x 0f 10
1715 * ==================================================================== */
1716void __bea_callspec__ movups_VW(PDISASM pMyDisasm)
1717{
1718 /* ========= 0xf2 */
1719 if (GV.PrefRepne == 1) {
1720 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1721 GV.MemDecoration = Arg2qword;
1722 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1723 #ifndef BEA_LIGHT_DISASSEMBLY
1724 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsd ");
1725 #endif
1726 GV.SSE_ = 1;
1727 GxEx(pMyDisasm);
1728 GV.SSE_ = 0;
1729 }
1730 /* ========= 0xf3 */
1731 else if (GV.PrefRepe == 1) {
1732 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1733 GV.MemDecoration = Arg2dword;
1734 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1735 #ifndef BEA_LIGHT_DISASSEMBLY
1736 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movss ");
1737 #endif
1738 GV.SSE_ = 1;
1739 GxEx(pMyDisasm);
1740 GV.SSE_ = 0;
1741 }
1742 /* ========== 0x66 */
1743 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1744 GV.OperandSize = GV.OriginalOperandSize;
1745 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1746 GV.MemDecoration = Arg2dqword;
1747 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1748 #ifndef BEA_LIGHT_DISASSEMBLY
1749 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movupd ");
1750 #endif
1751 GV.SSE_ = 1;
1752 GxEx(pMyDisasm);
1753 GV.SSE_ = 0;
1754 }
1755 else {
1756 GV.MemDecoration = Arg2dqword;
1757 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1758 #ifndef BEA_LIGHT_DISASSEMBLY
1759 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movups ");
1760 #endif
1761 GV.SSE_ = 1;
1762 GxEx(pMyDisasm);
1763 GV.SSE_ = 0;
1764 }
1765}
1766
1767
1768
1769/* ====================================================================
1770 * 0x 0f 11
1771 * ==================================================================== */
1772void __bea_callspec__ movups_WV(PDISASM pMyDisasm)
1773{
1774 /* ========= 0xf2 */
1775 if (GV.PrefRepne == 1) {
1776 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1777 GV.MemDecoration = Arg1qword;
1778 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1779 #ifndef BEA_LIGHT_DISASSEMBLY
1780 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movsd ");
1781 #endif
1782 GV.SSE_ = 1;
1783 ExGx(pMyDisasm);
1784 GV.SSE_ = 0;
1785 }
1786 /* ========= 0xf3 */
1787 else if (GV.PrefRepe == 1) {
1788 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1789 GV.MemDecoration = Arg1dword;
1790 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1791 #ifndef BEA_LIGHT_DISASSEMBLY
1792 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movss ");
1793 #endif
1794 GV.SSE_ = 1;
1795 ExGx(pMyDisasm);
1796 GV.SSE_ = 0;
1797 }
1798 /* ========== 0x66 */
1799 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1800 GV.OperandSize = GV.OriginalOperandSize;
1801 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1802 GV.MemDecoration = Arg1dqword;
1803 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1804 #ifndef BEA_LIGHT_DISASSEMBLY
1805 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movupd ");
1806 #endif
1807 GV.SSE_ = 1;
1808 ExGx(pMyDisasm);
1809 GV.SSE_ = 0;
1810 }
1811 else {
1812 GV.MemDecoration = Arg1dqword;
1813 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1814 #ifndef BEA_LIGHT_DISASSEMBLY
1815 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movups ");
1816 #endif
1817 GV.SSE_ = 1;
1818 ExGx(pMyDisasm);
1819 GV.SSE_ = 0;
1820 }
1821}
1822
1823
1824/* ====================================================================
1825 * 0x 0f 3a 42
1826 * ==================================================================== */
1827void __bea_callspec__ mpsadbw_(PDISASM pMyDisasm)
1828{
1829 /* ========== 0x66 */
1830 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1831 GV.OperandSize = GV.OriginalOperandSize;
1832 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1833 GV.MemDecoration = Arg2dqword;
1834 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+SAD_INSTRUCTION;
1835 #ifndef BEA_LIGHT_DISASSEMBLY
1836 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mpsadbw ");
1837 #endif
1838 GV.ImmediatSize = 8;
1839 GV.SSE_ = 1;
1840 GxEx(pMyDisasm);
1841 GV.SSE_ = 0;
1842 GV.EIP_++;
1843 if (!Security(0, pMyDisasm)) return;
1844 GV.third_arg = 1;
1845 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
1846 #ifndef BEA_LIGHT_DISASSEMBLY
1847 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
1848 #endif
1849 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
1850 (*pMyDisasm).Argument3.ArgSize = 8;
1851
1852
1853 }
1854 else {
1855 FailDecode(pMyDisasm);
1856 }
1857
1858}
1859
1860
1861/* ====================================================================
1862 * 0x 0f 59
1863 * ==================================================================== */
1864void __bea_callspec__ mulps_VW(PDISASM pMyDisasm)
1865{
1866 /* ========= 0xf2 */
1867 if (GV.PrefRepne == 1) {
1868 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
1869 GV.MemDecoration = Arg2qword;
1870 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1871 #ifndef BEA_LIGHT_DISASSEMBLY
1872 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mulsd ");
1873 #endif
1874 GV.SSE_ = 1;
1875 GxEx(pMyDisasm);
1876 GV.SSE_ = 0;
1877 }
1878 /* ========== 0xf3 */
1879 else if (GV.PrefRepe == 1) {
1880 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
1881 GV.MemDecoration = Arg2dword;
1882 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1883 #ifndef BEA_LIGHT_DISASSEMBLY
1884 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mulss ");
1885 #endif
1886 GV.SSE_ = 1;
1887 GxEx(pMyDisasm);
1888 GV.SSE_ = 0;
1889 }
1890 /* ========== 0x66 */
1891 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1892 GV.OperandSize = GV.OriginalOperandSize;
1893 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1894 GV.MemDecoration = Arg2dqword;
1895 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1896 #ifndef BEA_LIGHT_DISASSEMBLY
1897 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mulpd ");
1898 #endif
1899 GV.SSE_ = 1;
1900 GxEx(pMyDisasm);
1901 GV.SSE_ = 0;
1902 }
1903 else {
1904 GV.MemDecoration = Arg2dqword;
1905 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1906 #ifndef BEA_LIGHT_DISASSEMBLY
1907 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "mulps ");
1908 #endif
1909 GV.SSE_ = 1;
1910 GxEx(pMyDisasm);
1911 GV.SSE_ = 0;
1912 }
1913}
1914
1915
1916/* ====================================================================
1917 * 0x 0f 56
1918 * ==================================================================== */
1919void __bea_callspec__ orps_VW(PDISASM pMyDisasm)
1920{
1921 /* ========== 0x66 */
1922 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1923 GV.OperandSize = GV.OriginalOperandSize;
1924 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1925 GV.MemDecoration = Arg2dqword;
1926 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+LOGICAL_INSTRUCTION;
1927 #ifndef BEA_LIGHT_DISASSEMBLY
1928 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "orpd ");
1929 #endif
1930 GV.SSE_ = 1;
1931 GxEx(pMyDisasm);
1932 GV.SSE_ = 0;
1933 }
1934 else {
1935 GV.MemDecoration = Arg2dqword;
1936 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
1937 #ifndef BEA_LIGHT_DISASSEMBLY
1938 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "orps ");
1939 #endif
1940 GV.SSE_ = 1;
1941 GxEx(pMyDisasm);
1942 GV.SSE_ = 0;
1943 }
1944}
1945
1946
1947/* ====================================================================
1948 * 0x 0f 38 2b
1949 * ==================================================================== */
1950void __bea_callspec__ packusdw_(PDISASM pMyDisasm)
1951{
1952 /* ========== 0x66 */
1953 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1954 GV.OperandSize = GV.OriginalOperandSize;
1955 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1956 GV.MemDecoration = Arg2dqword;
1957 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
1958 #ifndef BEA_LIGHT_DISASSEMBLY
1959 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packusdw ");
1960 #endif
1961 GV.SSE_ = 1;
1962 GxEx(pMyDisasm);
1963 GV.SSE_ = 0;
1964
1965 }
1966 else {
1967 FailDecode(pMyDisasm);
1968 }
1969
1970}
1971
1972
1973/* ====================================================================
1974 * 0x 0f d4
1975 * ==================================================================== */
1976void __bea_callspec__ paddq_(PDISASM pMyDisasm)
1977{
1978 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
1979 /* ========== 0x66 */
1980 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1981 GV.OperandSize = GV.OriginalOperandSize;
1982 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1983 GV.MemDecoration = Arg2dqword;
1984 #ifndef BEA_LIGHT_DISASSEMBLY
1985 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddq ");
1986 #endif
1987 GV.SSE_ = 1;
1988 GxEx(pMyDisasm);
1989 GV.SSE_ = 0;
1990 }
1991 else {
1992 GV.MemDecoration = Arg2qword;
1993 #ifndef BEA_LIGHT_DISASSEMBLY
1994 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddq ");
1995 #endif
1996 GV.MMX_ = 1;
1997 GxEx(pMyDisasm);
1998 GV.MMX_ = 0;
1999 }
2000}
2001
2002
2003/* ====================================================================
2004 * 0x 0f e0
2005 * ==================================================================== */
2006void __bea_callspec__ pavgb_(PDISASM pMyDisasm)
2007{
2008 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2009 /* ========== 0x66 */
2010 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2011 GV.OperandSize = GV.OriginalOperandSize;
2012 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2013 GV.MemDecoration = Arg2dqword;
2014 #ifndef BEA_LIGHT_DISASSEMBLY
2015 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pavgb ");
2016 #endif
2017 GV.SSE_ = 1;
2018 GxEx(pMyDisasm);
2019 GV.SSE_ = 0;
2020 }
2021 else {
2022 GV.MemDecoration = Arg2qword;
2023 #ifndef BEA_LIGHT_DISASSEMBLY
2024 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pavgb ");
2025 #endif
2026 GV.MMX_ = 1;
2027 GxEx(pMyDisasm);
2028 GV.MMX_ = 0;
2029 }
2030}
2031
2032
2033/* ====================================================================
2034 * 0x 0f e3
2035 * ==================================================================== */
2036void __bea_callspec__ pavgw_(PDISASM pMyDisasm)
2037{
2038 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2039 /* ========== 0x66 */
2040 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2041 GV.OperandSize = GV.OriginalOperandSize;
2042 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2043 GV.MemDecoration = Arg2dqword;
2044 #ifndef BEA_LIGHT_DISASSEMBLY
2045 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pavgw ");
2046 #endif
2047 GV.SSE_ = 1;
2048 GxEx(pMyDisasm);
2049 GV.SSE_ = 0;
2050 }
2051 else {
2052 GV.MemDecoration = Arg2qword;
2053 #ifndef BEA_LIGHT_DISASSEMBLY
2054 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pavgw ");
2055 #endif
2056 GV.MMX_ = 1;
2057 GxEx(pMyDisasm);
2058 GV.MMX_ = 0;
2059 }
2060}
2061
2062
2063/* ====================================================================
2064 * 0x 0f 3a 0f
2065 * ==================================================================== */
2066void __bea_callspec__ palignr_(PDISASM pMyDisasm)
2067{
2068 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2069 /* ========== 0x66 */
2070 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2071 GV.OperandSize = GV.OriginalOperandSize;
2072 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2073 GV.MemDecoration = Arg2dqword;
2074 #ifndef BEA_LIGHT_DISASSEMBLY
2075 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "palignr ");
2076 #endif
2077 GV.ImmediatSize = 8;
2078 GV.SSE_ = 1;
2079 GxEx(pMyDisasm);
2080 GV.SSE_ = 0;
2081 GV.EIP_++;
2082 if (!Security(0, pMyDisasm)) return;
2083 GV.third_arg = 1;
2084 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2085 #ifndef BEA_LIGHT_DISASSEMBLY
2086 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2087 #endif
2088 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2089 (*pMyDisasm).Argument3.ArgSize = 8;
2090
2091 }
2092 else {
2093 GV.MemDecoration = Arg2qword;
2094 #ifndef BEA_LIGHT_DISASSEMBLY
2095 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "palignr ");
2096 #endif
2097 GV.ImmediatSize = 8;
2098 GV.MMX_ = 1;
2099 GxEx(pMyDisasm);
2100 GV.MMX_ = 0;
2101 GV.EIP_++;
2102 if (!Security(0, pMyDisasm)) return;
2103 GV.third_arg = 1;
2104 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2105 #ifndef BEA_LIGHT_DISASSEMBLY
2106 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2107 #endif
2108 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2109 (*pMyDisasm).Argument3.ArgSize = 8;
2110
2111 }
2112}
2113
2114
2115/* ====================================================================
2116 * 0x 0f 38 10
2117 * ==================================================================== */
2118void __bea_callspec__ pblendvb_(PDISASM pMyDisasm)
2119{
2120 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_BLENDING_INSTRUCTION;
2121 /* ========== 0x66 */
2122 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2123 GV.OperandSize = GV.OriginalOperandSize;
2124 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2125 GV.MemDecoration = Arg2dqword;
2126 #ifndef BEA_LIGHT_DISASSEMBLY
2127 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pblendvb ");
2128 #endif
2129 GV.SSE_ = 1;
2130 GxEx(pMyDisasm);
2131 GV.SSE_ = 0;
2132 }
2133 else {
2134 GV.MemDecoration = Arg2qword;
2135 #ifndef BEA_LIGHT_DISASSEMBLY
2136 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pblendvb ");
2137 #endif
2138 GV.MMX_ = 1;
2139 GxEx(pMyDisasm);
2140 GV.MMX_ = 0;
2141 }
2142}
2143
2144
2145/* ====================================================================
2146 * 0x 0f 3a 0e
2147 * ==================================================================== */
2148void __bea_callspec__ pblendw_(PDISASM pMyDisasm)
2149{
2150 /* ========== 0x66 */
2151 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2152 GV.OperandSize = GV.OriginalOperandSize;
2153 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2154 GV.MemDecoration = Arg2dqword;
2155 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+SAD_INSTRUCTION;
2156 #ifndef BEA_LIGHT_DISASSEMBLY
2157 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pblendw ");
2158 #endif
2159 GV.ImmediatSize = 8;
2160 GV.SSE_ = 1;
2161 GxEx(pMyDisasm);
2162 GV.SSE_ = 0;
2163 GV.EIP_++;
2164 if (!Security(0, pMyDisasm)) return;
2165 GV.third_arg = 1;
2166 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2167 #ifndef BEA_LIGHT_DISASSEMBLY
2168 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2169 #endif
2170 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2171 (*pMyDisasm).Argument3.ArgSize = 8;
2172
2173
2174 }
2175 else {
2176 FailDecode(pMyDisasm);
2177 }
2178
2179}
2180
2181
2182/* ====================================================================
2183 * 0x 0f 38 29
2184 * ==================================================================== */
2185void __bea_callspec__ pcmpeqq_(PDISASM pMyDisasm)
2186{
2187 /* ========== 0x66 */
2188 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2189 GV.OperandSize = GV.OriginalOperandSize;
2190 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2191 GV.MemDecoration = Arg2dqword;
2192 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_EQUALITY;
2193 #ifndef BEA_LIGHT_DISASSEMBLY
2194 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqq ");
2195 #endif
2196 GV.SSE_ = 1;
2197 GxEx(pMyDisasm);
2198 GV.SSE_ = 0;
2199
2200 }
2201 else {
2202 FailDecode(pMyDisasm);
2203 }
2204
2205}
2206
2207
2208/* ====================================================================
2209 * 0x 0f 3a 61
2210 * ==================================================================== */
2211void __bea_callspec__ pcmpestri_(PDISASM pMyDisasm)
2212{
2213 /* ========== 0x66 */
2214 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2215 GV.OperandSize = GV.OriginalOperandSize;
2216 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2217 GV.MemDecoration = Arg2dqword;
2218 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+COMPARISON_INSTRUCTION;
2219 #ifndef BEA_LIGHT_DISASSEMBLY
2220 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpestri ");
2221 #endif
2222 GV.ImmediatSize = 8;
2223 GV.SSE_ = 1;
2224 GxEx(pMyDisasm);
2225 GV.SSE_ = 0;
2226 GV.EIP_++;
2227 if (!Security(0, pMyDisasm)) return;
2228 GV.third_arg = 1;
2229 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2230 #ifndef BEA_LIGHT_DISASSEMBLY
2231 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2232 #endif
2233 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2234 (*pMyDisasm).Argument3.ArgSize = 8;
2235
2236
2237 }
2238 else {
2239 FailDecode(pMyDisasm);
2240 }
2241
2242}
2243
2244
2245/* ====================================================================
2246 * 0x 0f 3a 60
2247 * ==================================================================== */
2248void __bea_callspec__ pcmpestrm_(PDISASM pMyDisasm)
2249{
2250 /* ========== 0x66 */
2251 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2252 GV.OperandSize = GV.OriginalOperandSize;
2253 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2254 GV.MemDecoration = Arg2dqword;
2255 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+COMPARISON_INSTRUCTION;
2256 #ifndef BEA_LIGHT_DISASSEMBLY
2257 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpestrm ");
2258 #endif
2259 GV.ImmediatSize = 8;
2260 GV.SSE_ = 1;
2261 GxEx(pMyDisasm);
2262 GV.SSE_ = 0;
2263 GV.EIP_++;
2264 if (!Security(0, pMyDisasm)) return;
2265 GV.third_arg = 1;
2266 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2267 #ifndef BEA_LIGHT_DISASSEMBLY
2268 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2269 #endif
2270 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2271 (*pMyDisasm).Argument3.ArgSize = 8;
2272
2273
2274 }
2275 else {
2276 FailDecode(pMyDisasm);
2277 }
2278
2279}
2280
2281
2282/* ====================================================================
2283 * 0x 0f 3a 63
2284 * ==================================================================== */
2285void __bea_callspec__ pcmpistri_(PDISASM pMyDisasm)
2286{
2287 /* ========== 0x66 */
2288 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2289 GV.OperandSize = GV.OriginalOperandSize;
2290 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2291 GV.MemDecoration = Arg2dqword;
2292 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+COMPARISON_INSTRUCTION;
2293 #ifndef BEA_LIGHT_DISASSEMBLY
2294 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpistri ");
2295 #endif
2296 GV.ImmediatSize = 8;
2297 GV.SSE_ = 1;
2298 GxEx(pMyDisasm);
2299 GV.SSE_ = 0;
2300 GV.EIP_++;
2301 if (!Security(0, pMyDisasm)) return;
2302 GV.third_arg = 1;
2303 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2304 #ifndef BEA_LIGHT_DISASSEMBLY
2305 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2306 #endif
2307 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2308 (*pMyDisasm).Argument3.ArgSize = 8;
2309
2310
2311 }
2312 else {
2313 FailDecode(pMyDisasm);
2314 }
2315
2316}
2317
2318
2319/* ====================================================================
2320 * 0x 0f 3a 62
2321 * ==================================================================== */
2322void __bea_callspec__ pcmpistrm_(PDISASM pMyDisasm)
2323{
2324 /* ========== 0x66 */
2325 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2326 GV.OperandSize = GV.OriginalOperandSize;
2327 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2328 GV.MemDecoration = Arg2dqword;
2329 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+COMPARISON_INSTRUCTION;
2330 #ifndef BEA_LIGHT_DISASSEMBLY
2331 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpestrm ");
2332 #endif
2333 GV.ImmediatSize = 8;
2334 GV.SSE_ = 1;
2335 GxEx(pMyDisasm);
2336 GV.SSE_ = 0;
2337 GV.EIP_++;
2338 if (!Security(0, pMyDisasm)) return;
2339 GV.third_arg = 1;
2340 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2341 #ifndef BEA_LIGHT_DISASSEMBLY
2342 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2343 #endif
2344 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2345 (*pMyDisasm).Argument3.ArgSize = 8;
2346
2347
2348 }
2349 else {
2350 FailDecode(pMyDisasm);
2351 }
2352
2353}
2354
2355
2356/* ====================================================================
2357 * 0x 0f 38 37
2358 * ==================================================================== */
2359void __bea_callspec__ pcmpgtq_(PDISASM pMyDisasm)
2360{
2361 /* ========== 0x66 */
2362 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2363 GV.OperandSize = GV.OriginalOperandSize;
2364 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2365 GV.MemDecoration = Arg2dqword;
2366 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+COMPARISON_INSTRUCTION;
2367 #ifndef BEA_LIGHT_DISASSEMBLY
2368 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtq ");
2369 #endif
2370 GV.SSE_ = 1;
2371 GxEx(pMyDisasm);
2372 GV.SSE_ = 0;
2373
2374 }
2375 else {
2376 FailDecode(pMyDisasm);
2377 }
2378
2379}
2380
2381
2382/* ====================================================================
2383 * 0x 0f 3a 14
2384 * ==================================================================== */
2385void __bea_callspec__ pextrb_(PDISASM pMyDisasm)
2386{
2387 /* ========== 0x66 */
2388 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2389 GV.OperandSize = GV.OriginalOperandSize;
2390 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2391 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
2392 #ifndef BEA_LIGHT_DISASSEMBLY
2393 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrb ");
2394 #endif
2395 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
2396 if (GV.MOD_== 0x3) {
2397 GV.MemDecoration = Arg1dword;
2398 }
2399 else {
2400 GV.MemDecoration = Arg1byte;
2401 }
2402 GV.ImmediatSize = 8;
2403 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2404 GV.SSE_ = 1;
2405 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
2406 GV.SSE_ = 0;
2407 GV.EIP_ += GV.DECALAGE_EIP+3;
2408 if (!Security(0, pMyDisasm)) return;
2409 GV.third_arg = 1;
2410 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2411 #ifndef BEA_LIGHT_DISASSEMBLY
2412 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2413 #endif
2414 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2415 (*pMyDisasm).Argument3.ArgSize = 8;
2416
2417
2418 }
2419 else {
2420 FailDecode(pMyDisasm);
2421 }
2422
2423}
2424
2425
2426/* ====================================================================
2427 * 0x 0f 3a 16
2428 * ==================================================================== */
2429void __bea_callspec__ pextrd_(PDISASM pMyDisasm)
2430{
2431 /* ========== 0x66 */
2432 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2433 GV.OperandSize = GV.OriginalOperandSize;
2434 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2435 GV.MemDecoration = Arg2dqword;
2436 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
2437 if (GV.REX.W_ == 0x1) {
2438 #ifndef BEA_LIGHT_DISASSEMBLY
2439 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrq ");
2440 #endif
2441 GV.MemDecoration = Arg1qword;
2442 GV.OperandSize = 64;
2443 }
2444 else {
2445 #ifndef BEA_LIGHT_DISASSEMBLY
2446 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrd ");
2447 #endif
2448 GV.MemDecoration = Arg1dword;
2449 }
2450 GV.ImmediatSize = 8;
2451 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2452 GV.SSE_ = 1;
2453 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
2454 GV.SSE_ = 0;
2455 GV.EIP_ += GV.DECALAGE_EIP+3;
2456 if (!Security(0, pMyDisasm)) return;
2457 GV.third_arg = 1;
2458 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2459 #ifndef BEA_LIGHT_DISASSEMBLY
2460 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2461 #endif
2462 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2463 (*pMyDisasm).Argument3.ArgSize = 8;
2464
2465
2466 }
2467 else {
2468 FailDecode(pMyDisasm);
2469 }
2470
2471}
2472
2473/* ====================================================================
2474 * 0x 0f c5
2475 * ==================================================================== */
2476void __bea_callspec__ pextrw_(PDISASM pMyDisasm)
2477{
2478 /* ========== 0x66 */
2479 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2480 GV.OperandSize = GV.OriginalOperandSize;
2481 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2482 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2483 #ifndef BEA_LIGHT_DISASSEMBLY
2484 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrw ");
2485 #endif
2486 GV.MemDecoration = Arg2dqword;
2487 GV.ImmediatSize = 8;
2488 GV.SSE_ = 1;
2489 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2490 GV.SSE_ = 0;
2491 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2492 GV.EIP_ += GV.DECALAGE_EIP+3;
2493 if (!Security(0, pMyDisasm)) return;
2494 GV.third_arg = 1;
2495 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2496 #ifndef BEA_LIGHT_DISASSEMBLY
2497 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2498 #endif
2499 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2500 (*pMyDisasm).Argument3.ArgSize = 8;
2501
2502
2503 }
2504 else {
2505 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2506 #ifndef BEA_LIGHT_DISASSEMBLY
2507 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrw ");
2508 #endif
2509 GV.MemDecoration = Arg2dqword;
2510 GV.ImmediatSize = 8;
2511 GV.MMX_ = 1;
2512 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2513 GV.MMX_ = 0;
2514 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2515 GV.EIP_ += GV.DECALAGE_EIP+3;
2516 if (!Security(0, pMyDisasm)) return;
2517 GV.third_arg = 1;
2518 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2519 #ifndef BEA_LIGHT_DISASSEMBLY
2520 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2521 #endif
2522 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2523 (*pMyDisasm).Argument3.ArgSize = 8;
2524
2525 }
2526
2527}
2528
2529/* ====================================================================
2530 * 0x 0f 3a 15
2531 * ==================================================================== */
2532void __bea_callspec__ pextrw2_(PDISASM pMyDisasm)
2533{
2534 /* ========== 0x66 */
2535 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2536 GV.OperandSize = GV.OriginalOperandSize;
2537 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2538 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
2539 #ifndef BEA_LIGHT_DISASSEMBLY
2540 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pextrw ");
2541 #endif
2542 GV.MOD_= ((*((UInt8*)(UIntPtr) (GV.EIP_+1))) >> 6) & 0x3;
2543 if (GV.MOD_== 0x3) {
2544 GV.MemDecoration = Arg1dword;
2545 }
2546 else {
2547 GV.MemDecoration = Arg1word;
2548 }
2549 GV.ImmediatSize = 8;
2550 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2551 GV.SSE_ = 1;
2552 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
2553 GV.SSE_ = 0;
2554 GV.EIP_ += GV.DECALAGE_EIP+3;
2555 if (!Security(0, pMyDisasm)) return;
2556 GV.third_arg = 1;
2557 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2558 #ifndef BEA_LIGHT_DISASSEMBLY
2559 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2560 #endif
2561 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2562 (*pMyDisasm).Argument3.ArgSize = 8;
2563
2564
2565 }
2566 else {
2567 FailDecode(pMyDisasm);
2568 }
2569
2570}
2571
2572
2573/* ====================================================================
2574 * 0x 0f 38 02
2575 * ==================================================================== */
2576void __bea_callspec__ phaddd_(PDISASM pMyDisasm)
2577{
2578 /* ========== 0x66 */
2579 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2580 GV.OperandSize = GV.OriginalOperandSize;
2581 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2582 GV.MemDecoration = Arg2dqword;
2583 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2584 #ifndef BEA_LIGHT_DISASSEMBLY
2585 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddd ");
2586 #endif
2587 GV.SSE_ = 1;
2588 GxEx(pMyDisasm);
2589 GV.SSE_ = 0;
2590 }
2591 else {
2592 GV.MemDecoration = Arg2qword;
2593 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2594 #ifndef BEA_LIGHT_DISASSEMBLY
2595 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddd ");
2596 #endif
2597 GV.MMX_ = 1;
2598 GxEx(pMyDisasm);
2599 GV.MMX_ = 0;
2600 }
2601}
2602
2603
2604/* ====================================================================
2605 * 0x 0f 38 03
2606 * ==================================================================== */
2607void __bea_callspec__ phaddsw_(PDISASM pMyDisasm)
2608{
2609 /* ========== 0x66 */
2610 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2611 GV.OperandSize = GV.OriginalOperandSize;
2612 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2613 GV.MemDecoration = Arg2dqword;
2614 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2615 #ifndef BEA_LIGHT_DISASSEMBLY
2616 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddsw ");
2617 #endif
2618 GV.SSE_ = 1;
2619 GxEx(pMyDisasm);
2620 GV.SSE_ = 0;
2621 }
2622 else {
2623 GV.MemDecoration = Arg2qword;
2624 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2625 #ifndef BEA_LIGHT_DISASSEMBLY
2626 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddsw ");
2627 #endif
2628 GV.MMX_ = 1;
2629 GxEx(pMyDisasm);
2630 GV.MMX_ = 0;
2631 }
2632}
2633
2634
2635/* ====================================================================
2636 * 0x 0f 38 01
2637 * ==================================================================== */
2638void __bea_callspec__ phaddw_(PDISASM pMyDisasm)
2639{
2640 /* ========== 0x66 */
2641 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2642 GV.OperandSize = GV.OriginalOperandSize;
2643 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2644 GV.MemDecoration = Arg2dqword;
2645 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2646 #ifndef BEA_LIGHT_DISASSEMBLY
2647 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddw ");
2648 #endif
2649 GV.SSE_ = 1;
2650 GxEx(pMyDisasm);
2651 GV.SSE_ = 0;
2652 }
2653 else {
2654 GV.MemDecoration = Arg2qword;
2655 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2656 #ifndef BEA_LIGHT_DISASSEMBLY
2657 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phaddw ");
2658 #endif
2659 GV.MMX_ = 1;
2660 GxEx(pMyDisasm);
2661 GV.MMX_ = 0;
2662 }
2663}
2664
2665
2666/* ====================================================================
2667 * 0x 0f 38 41
2668 * ==================================================================== */
2669void __bea_callspec__ phminposuw_(PDISASM pMyDisasm)
2670{
2671 /* ========== 0x66 */
2672 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2673 GV.OperandSize = GV.OriginalOperandSize;
2674 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2675 GV.MemDecoration = Arg2dqword;
2676 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+HORIZONTAL_SEARCH;
2677 #ifndef BEA_LIGHT_DISASSEMBLY
2678 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phminposuw ");
2679 #endif
2680 GV.SSE_ = 1;
2681 GxEx(pMyDisasm);
2682 GV.SSE_ = 0;
2683 }
2684 else {
2685 FailDecode(pMyDisasm);
2686 }
2687}
2688
2689
2690/* ====================================================================
2691 * 0x 0f 38 05
2692 * ==================================================================== */
2693void __bea_callspec__ phsubw_(PDISASM pMyDisasm)
2694{
2695 /* ========== 0x66 */
2696 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2697 GV.OperandSize = GV.OriginalOperandSize;
2698 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2699 GV.MemDecoration = Arg2dqword;
2700 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2701 #ifndef BEA_LIGHT_DISASSEMBLY
2702 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubw ");
2703 #endif
2704 GV.SSE_ = 1;
2705 GxEx(pMyDisasm);
2706 GV.SSE_ = 0;
2707 }
2708 else {
2709 GV.MemDecoration = Arg2qword;
2710 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2711 #ifndef BEA_LIGHT_DISASSEMBLY
2712 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubw ");
2713 #endif
2714 GV.MMX_ = 1;
2715 GxEx(pMyDisasm);
2716 GV.MMX_ = 0;
2717 }
2718}
2719
2720
2721/* ====================================================================
2722 * 0x 0f 38 06
2723 * ==================================================================== */
2724void __bea_callspec__ phsubd_(PDISASM pMyDisasm)
2725{
2726 /* ========== 0x66 */
2727 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2728 GV.OperandSize = GV.OriginalOperandSize;
2729 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2730 GV.MemDecoration = Arg2dqword;
2731 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2732 #ifndef BEA_LIGHT_DISASSEMBLY
2733 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubd ");
2734 #endif
2735 GV.SSE_ = 1;
2736 GxEx(pMyDisasm);
2737 GV.SSE_ = 0;
2738 }
2739 else {
2740 GV.MemDecoration = Arg2qword;
2741 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2742 #ifndef BEA_LIGHT_DISASSEMBLY
2743 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubd ");
2744 #endif
2745 GV.MMX_ = 1;
2746 GxEx(pMyDisasm);
2747 GV.MMX_ = 0;
2748 }
2749}
2750
2751
2752/* ====================================================================
2753 * 0x 0f 38 07
2754 * ==================================================================== */
2755void __bea_callspec__ phsubsw_(PDISASM pMyDisasm)
2756{
2757 /* ========== 0x66 */
2758 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2759 GV.OperandSize = GV.OriginalOperandSize;
2760 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2761 GV.MemDecoration = Arg2dqword;
2762 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2763 #ifndef BEA_LIGHT_DISASSEMBLY
2764 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubsw ");
2765 #endif
2766 GV.SSE_ = 1;
2767 GxEx(pMyDisasm);
2768 GV.SSE_ = 0;
2769 }
2770 else {
2771 GV.MemDecoration = Arg2qword;
2772 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
2773 #ifndef BEA_LIGHT_DISASSEMBLY
2774 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "phsubsw ");
2775 #endif
2776 GV.MMX_ = 1;
2777 GxEx(pMyDisasm);
2778 GV.MMX_ = 0;
2779 }
2780}
2781
2782
2783/* ====================================================================
2784 * 0x 0f 3a 20
2785 * ==================================================================== */
2786void __bea_callspec__ pinsrb_(PDISASM pMyDisasm)
2787{
2788 /* ========== 0x66 */
2789 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2790 GV.OperandSize = GV.OriginalOperandSize;
2791 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2792 GV.MemDecoration = Arg2byte;
2793 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
2794 #ifndef BEA_LIGHT_DISASSEMBLY
2795 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrb ");
2796 #endif
2797 GV.ImmediatSize = 8;
2798 GV.SSE_ = 1;
2799 GxEx(pMyDisasm);
2800 GV.SSE_ = 0;
2801 GV.EIP_++;
2802 if (!Security(0, pMyDisasm)) return;
2803 GV.third_arg = 1;
2804 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2805 #ifndef BEA_LIGHT_DISASSEMBLY
2806 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2807 #endif
2808 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2809 (*pMyDisasm).Argument3.ArgSize = 8;
2810
2811
2812 }
2813 else {
2814 FailDecode(pMyDisasm);
2815 }
2816
2817}
2818
2819
2820/* ====================================================================
2821 * 0x 0f 3a 22
2822 * ==================================================================== */
2823void __bea_callspec__ pinsrd_(PDISASM pMyDisasm)
2824{
2825 /* ========== 0x66 */
2826 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2827 GV.OperandSize = GV.OriginalOperandSize;
2828 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2829 GV.MemDecoration = Arg2dqword;
2830 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+INSERTION_EXTRACTION;
2831 if (GV.REX.W_ == 0x1) {
2832 #ifndef BEA_LIGHT_DISASSEMBLY
2833 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrq ");
2834 #endif
2835 GV.MemDecoration = Arg1qword;
2836 }
2837 else {
2838 #ifndef BEA_LIGHT_DISASSEMBLY
2839 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrd ");
2840 #endif
2841 GV.MemDecoration = Arg1dword;
2842 }
2843 GV.ImmediatSize = 8;
2844 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
2845 GV.SSE_ = 1;
2846 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
2847 GV.SSE_ = 0;
2848 GV.EIP_ += GV.DECALAGE_EIP+3;
2849 if (!Security(0, pMyDisasm)) return;
2850 GV.third_arg = 1;
2851 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2852 #ifndef BEA_LIGHT_DISASSEMBLY
2853 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2854 #endif
2855 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2856 (*pMyDisasm).Argument3.ArgSize = 8;
2857
2858
2859 }
2860 else {
2861 FailDecode(pMyDisasm);
2862 }
2863
2864}
2865
2866
2867/* ====================================================================
2868 * 0x 0f c4
2869 * ==================================================================== */
2870void __bea_callspec__ pinsrw_(PDISASM pMyDisasm)
2871{
2872 /* ========== 0x66 */
2873 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2874 GV.OperandSize = GV.OriginalOperandSize;
2875 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2876 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2877 #ifndef BEA_LIGHT_DISASSEMBLY
2878 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrw ");
2879 #endif
2880 GV.MemDecoration = Arg2word;
2881 GV.ImmediatSize = 8;
2882 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2883 GV.SSE_ = 1;
2884 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2885 GV.SSE_ = 0;
2886 GV.EIP_ += GV.DECALAGE_EIP+3;
2887 if (!Security(0, pMyDisasm)) return;
2888 GV.third_arg = 1;
2889 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2890 #ifndef BEA_LIGHT_DISASSEMBLY
2891 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2892 #endif
2893 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2894 (*pMyDisasm).Argument3.ArgSize = 8;
2895
2896
2897 }
2898 else {
2899 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
2900 #ifndef BEA_LIGHT_DISASSEMBLY
2901 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pinsrw ");
2902 #endif
2903 GV.MemDecoration = Arg2word;
2904 GV.ImmediatSize = 8;
2905 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
2906 GV.MMX_ = 1;
2907 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
2908 GV.MMX_ = 0;
2909 GV.EIP_ += GV.DECALAGE_EIP+3;
2910 if (!Security(0, pMyDisasm)) return;
2911 GV.third_arg = 1;
2912 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
2913 #ifndef BEA_LIGHT_DISASSEMBLY
2914 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
2915 #endif
2916 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
2917 (*pMyDisasm).Argument3.ArgSize = 8;
2918
2919 }
2920
2921}
2922
2923
2924/* ====================================================================
2925 * 0x 0f 38 3c
2926 * ==================================================================== */
2927void __bea_callspec__ pmaxsb_(PDISASM pMyDisasm)
2928{
2929 /* ========== 0x66 */
2930 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2931 GV.OperandSize = GV.OriginalOperandSize;
2932 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2933 GV.MemDecoration = Arg2dqword;
2934 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
2935 #ifndef BEA_LIGHT_DISASSEMBLY
2936 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxsb ");
2937 #endif
2938 GV.SSE_ = 1;
2939 GxEx(pMyDisasm);
2940 GV.SSE_ = 0;
2941 }
2942 else {
2943 FailDecode(pMyDisasm);
2944 }
2945}
2946
2947/* ====================================================================
2948 * 0x 0f 38 3d
2949 * ==================================================================== */
2950void __bea_callspec__ pmaxsd_(PDISASM pMyDisasm)
2951{
2952 /* ========== 0x66 */
2953 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2954 GV.OperandSize = GV.OriginalOperandSize;
2955 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2956 GV.MemDecoration = Arg2dqword;
2957 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
2958 #ifndef BEA_LIGHT_DISASSEMBLY
2959 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxsd ");
2960 #endif
2961 GV.SSE_ = 1;
2962 GxEx(pMyDisasm);
2963 GV.SSE_ = 0;
2964 }
2965 else {
2966 FailDecode(pMyDisasm);
2967 }
2968}
2969
2970/* ====================================================================
2971 * 0x 0f 38 3e
2972 * ==================================================================== */
2973void __bea_callspec__ pmaxuw_(PDISASM pMyDisasm)
2974{
2975 /* ========== 0x66 */
2976 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
2977 GV.OperandSize = GV.OriginalOperandSize;
2978 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
2979 GV.MemDecoration = Arg2dqword;
2980 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
2981 #ifndef BEA_LIGHT_DISASSEMBLY
2982 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxuw ");
2983 #endif
2984 GV.SSE_ = 1;
2985 GxEx(pMyDisasm);
2986 GV.SSE_ = 0;
2987 }
2988 else {
2989 FailDecode(pMyDisasm);
2990 }
2991}
2992
2993/* ====================================================================
2994 * 0x 0f 38 3f
2995 * ==================================================================== */
2996void __bea_callspec__ pmaxud_(PDISASM pMyDisasm)
2997{
2998 /* ========== 0x66 */
2999 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3000 GV.OperandSize = GV.OriginalOperandSize;
3001 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3002 GV.MemDecoration = Arg2dqword;
3003 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
3004 #ifndef BEA_LIGHT_DISASSEMBLY
3005 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxud ");
3006 #endif
3007 GV.SSE_ = 1;
3008 GxEx(pMyDisasm);
3009 GV.SSE_ = 0;
3010 }
3011 else {
3012 FailDecode(pMyDisasm);
3013 }
3014}
3015
3016/* ====================================================================
3017 * 0x 0f 38 38
3018 * ==================================================================== */
3019void __bea_callspec__ pminsb_(PDISASM pMyDisasm)
3020{
3021 /* ========== 0x66 */
3022 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3023 GV.OperandSize = GV.OriginalOperandSize;
3024 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3025 GV.MemDecoration = Arg2dqword;
3026 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
3027 #ifndef BEA_LIGHT_DISASSEMBLY
3028 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminsb ");
3029 #endif
3030 GV.SSE_ = 1;
3031 GxEx(pMyDisasm);
3032 GV.SSE_ = 0;
3033 }
3034 else {
3035 FailDecode(pMyDisasm);
3036 }
3037}
3038
3039/* ====================================================================
3040 * 0x 0f 38 39
3041 * ==================================================================== */
3042void __bea_callspec__ pminsd_(PDISASM pMyDisasm)
3043{
3044 /* ========== 0x66 */
3045 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3046 GV.OperandSize = GV.OriginalOperandSize;
3047 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3048 GV.MemDecoration = Arg2dqword;
3049 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
3050 #ifndef BEA_LIGHT_DISASSEMBLY
3051 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminsd ");
3052 #endif
3053 GV.SSE_ = 1;
3054 GxEx(pMyDisasm);
3055 GV.SSE_ = 0;
3056 }
3057 else {
3058 FailDecode(pMyDisasm);
3059 }
3060}
3061
3062/* ====================================================================
3063 * 0x 0f 38 3a
3064 * ==================================================================== */
3065void __bea_callspec__ pminuw_(PDISASM pMyDisasm)
3066{
3067 /* ========== 0x66 */
3068 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3069 GV.OperandSize = GV.OriginalOperandSize;
3070 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3071 GV.MemDecoration = Arg2dqword;
3072 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
3073 #ifndef BEA_LIGHT_DISASSEMBLY
3074 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminuw ");
3075 #endif
3076 GV.SSE_ = 1;
3077 GxEx(pMyDisasm);
3078 GV.SSE_ = 0;
3079 }
3080 else {
3081 FailDecode(pMyDisasm);
3082 }
3083}
3084
3085/* ====================================================================
3086 * 0x 0f 38 3b
3087 * ==================================================================== */
3088void __bea_callspec__ pminud_(PDISASM pMyDisasm)
3089{
3090 /* ========== 0x66 */
3091 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3092 GV.OperandSize = GV.OriginalOperandSize;
3093 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3094 GV.MemDecoration = Arg2dqword;
3095 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_MINMAX;
3096 #ifndef BEA_LIGHT_DISASSEMBLY
3097 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminud ");
3098 #endif
3099 GV.SSE_ = 1;
3100 GxEx(pMyDisasm);
3101 GV.SSE_ = 0;
3102 }
3103 else {
3104 FailDecode(pMyDisasm);
3105 }
3106}
3107
3108
3109/* ====================================================================
3110 * 0x 0f da
3111 * ==================================================================== */
3112void __bea_callspec__ pminub_(PDISASM pMyDisasm)
3113{
3114 /* ========== 0x66 */
3115 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3116 GV.OperandSize = GV.OriginalOperandSize;
3117 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3118 GV.MemDecoration = Arg2dqword;
3119 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3120 #ifndef BEA_LIGHT_DISASSEMBLY
3121 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminub ");
3122 #endif
3123 GV.SSE_ = 1;
3124 GxEx(pMyDisasm);
3125 GV.SSE_ = 0;
3126 }
3127 else {
3128 GV.MemDecoration = Arg2qword;
3129 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3130 #ifndef BEA_LIGHT_DISASSEMBLY
3131 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminub ");
3132 #endif
3133 GV.MMX_ = 1;
3134 GxEx(pMyDisasm);
3135 GV.MMX_ = 0;
3136 }
3137}
3138
3139
3140/* ====================================================================
3141 * 0x 0f de
3142 * ==================================================================== */
3143void __bea_callspec__ pmaxub_(PDISASM pMyDisasm)
3144{
3145 /* ========== 0x66 */
3146 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3147 GV.OperandSize = GV.OriginalOperandSize;
3148 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3149 GV.MemDecoration = Arg2dqword;
3150 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3151 #ifndef BEA_LIGHT_DISASSEMBLY
3152 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxub ");
3153 #endif
3154 GV.SSE_ = 1;
3155 GxEx(pMyDisasm);
3156 GV.SSE_ = 0;
3157 }
3158 else {
3159 GV.MemDecoration = Arg2qword;
3160 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3161 #ifndef BEA_LIGHT_DISASSEMBLY
3162 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxub ");
3163 #endif
3164 GV.MMX_ = 1;
3165 GxEx(pMyDisasm);
3166 GV.MMX_ = 0;
3167 }
3168}
3169
3170
3171/* ====================================================================
3172 * 0x 0f ea
3173 * ==================================================================== */
3174void __bea_callspec__ pminsw_(PDISASM pMyDisasm)
3175{
3176 /* ========== 0x66 */
3177 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3178 GV.OperandSize = GV.OriginalOperandSize;
3179 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3180 GV.MemDecoration = Arg2dqword;
3181 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3182 #ifndef BEA_LIGHT_DISASSEMBLY
3183 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminsw ");
3184 #endif
3185 GV.SSE_ = 1;
3186 GxEx(pMyDisasm);
3187 GV.SSE_ = 0;
3188 }
3189 else {
3190 GV.MemDecoration = Arg2qword;
3191 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3192 #ifndef BEA_LIGHT_DISASSEMBLY
3193 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pminsw ");
3194 #endif
3195 GV.MMX_ = 1;
3196 GxEx(pMyDisasm);
3197 GV.MMX_ = 0;
3198 }
3199}
3200
3201
3202/* ====================================================================
3203 * 0x 0f ee
3204 * ==================================================================== */
3205void __bea_callspec__ pmaxsw_(PDISASM pMyDisasm)
3206{
3207 /* ========== 0x66 */
3208 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3209 GV.OperandSize = GV.OriginalOperandSize;
3210 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3211 GV.MemDecoration = Arg2dqword;
3212 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3213 #ifndef BEA_LIGHT_DISASSEMBLY
3214 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxsw ");
3215 #endif
3216 GV.SSE_ = 1;
3217 GxEx(pMyDisasm);
3218 GV.SSE_ = 0;
3219 }
3220 else {
3221 GV.MemDecoration = Arg2qword;
3222 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3223 #ifndef BEA_LIGHT_DISASSEMBLY
3224 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaxsw ");
3225 #endif
3226 GV.MMX_ = 1;
3227 GxEx(pMyDisasm);
3228 GV.MMX_ = 0;
3229 }
3230}
3231
3232
3233/* ====================================================================
3234 * 0x 0f 38 04
3235 * ==================================================================== */
3236void __bea_callspec__ pmaddubsw_(PDISASM pMyDisasm)
3237{
3238 /* ========== 0x66 */
3239 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3240 GV.OperandSize = GV.OriginalOperandSize;
3241 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3242 GV.MemDecoration = Arg2dqword;
3243 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3244 #ifndef BEA_LIGHT_DISASSEMBLY
3245 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaddubsw ");
3246 #endif
3247 GV.SSE_ = 1;
3248 GxEx(pMyDisasm);
3249 GV.SSE_ = 0;
3250 }
3251 else {
3252 GV.MemDecoration = Arg2qword;
3253 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3254 #ifndef BEA_LIGHT_DISASSEMBLY
3255 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaddubsw ");
3256 #endif
3257 GV.MMX_ = 1;
3258 GxEx(pMyDisasm);
3259 GV.MMX_ = 0;
3260 }
3261}
3262
3263
3264/* ====================================================================
3265 * 0x 0f d7
3266 * ==================================================================== */
3267void __bea_callspec__ pmovmskb_(PDISASM pMyDisasm)
3268{
3269 /* ========== 0x66 */
3270 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3271
3272 GV.OperandSize = GV.OriginalOperandSize;
3273 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3274 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3275 #ifndef BEA_LIGHT_DISASSEMBLY
3276 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovmskb ");
3277 #endif
3278 GV.MemDecoration = Arg2dqword;
3279 GV.SSE_ = 1;
3280 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
3281 GV.SSE_ = 0;
3282 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
3283 GV.EIP_ += GV.DECALAGE_EIP+2;
3284 }
3285 else {
3286 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3287 #ifndef BEA_LIGHT_DISASSEMBLY
3288 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovmskb ");
3289 #endif
3290 GV.MemDecoration = Arg2qword;
3291 GV.MMX_ = 1;
3292 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
3293 GV.MMX_ = 0;
3294 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
3295 GV.EIP_ += GV.DECALAGE_EIP+2;
3296 }
3297
3298}
3299
3300
3301/* ====================================================================
3302 * 0x 0f 38 21
3303 * ==================================================================== */
3304void __bea_callspec__ pmovsxbd_(PDISASM pMyDisasm)
3305{
3306 /* ========== 0x66 */
3307 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3308 GV.OperandSize = GV.OriginalOperandSize;
3309 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3310 GV.MemDecoration = Arg2dqword;
3311 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3312 #ifndef BEA_LIGHT_DISASSEMBLY
3313 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxbd ");
3314 #endif
3315 GV.SSE_ = 1;
3316 GxEx(pMyDisasm);
3317 GV.SSE_ = 0;
3318 }
3319 else {
3320 FailDecode(pMyDisasm);
3321 }
3322}
3323
3324
3325/* ====================================================================
3326 * 0x 0f 38 22
3327 * ==================================================================== */
3328void __bea_callspec__ pmovsxbq_(PDISASM pMyDisasm)
3329{
3330 /* ========== 0x66 */
3331 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3332 GV.OperandSize = GV.OriginalOperandSize;
3333 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3334 GV.MemDecoration = Arg2dqword;
3335 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3336 #ifndef BEA_LIGHT_DISASSEMBLY
3337 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxbq ");
3338 #endif
3339 GV.SSE_ = 1;
3340 GxEx(pMyDisasm);
3341 GV.SSE_ = 0;
3342 }
3343 else {
3344 FailDecode(pMyDisasm);
3345 }
3346}
3347
3348
3349/* ====================================================================
3350 * 0x 0f 38 20
3351 * ==================================================================== */
3352void __bea_callspec__ pmovsxbw_(PDISASM pMyDisasm)
3353{
3354 /* ========== 0x66 */
3355 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3356 GV.OperandSize = GV.OriginalOperandSize;
3357 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3358 GV.MemDecoration = Arg2dqword;
3359 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3360 #ifndef BEA_LIGHT_DISASSEMBLY
3361 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxbw ");
3362 #endif
3363 GV.SSE_ = 1;
3364 GxEx(pMyDisasm);
3365 GV.SSE_ = 0;
3366 }
3367 else {
3368 FailDecode(pMyDisasm);
3369 }
3370}
3371
3372
3373/* ====================================================================
3374 * 0x 0f 38 25
3375 * ==================================================================== */
3376void __bea_callspec__ pmovsxdq_(PDISASM pMyDisasm)
3377{
3378 /* ========== 0x66 */
3379 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3380 GV.OperandSize = GV.OriginalOperandSize;
3381 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3382 GV.MemDecoration = Arg2dqword;
3383 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3384 #ifndef BEA_LIGHT_DISASSEMBLY
3385 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxdq ");
3386 #endif
3387 GV.SSE_ = 1;
3388 GxEx(pMyDisasm);
3389 GV.SSE_ = 0;
3390 }
3391 else {
3392 FailDecode(pMyDisasm);
3393 }
3394}
3395
3396
3397/* ====================================================================
3398 * 0x 0f 38 23
3399 * ==================================================================== */
3400void __bea_callspec__ pmovsxwd_(PDISASM pMyDisasm)
3401{
3402 /* ========== 0x66 */
3403 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3404 GV.OperandSize = GV.OriginalOperandSize;
3405 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3406 GV.MemDecoration = Arg2dqword;
3407 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3408 #ifndef BEA_LIGHT_DISASSEMBLY
3409 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxwd ");
3410 #endif
3411 GV.SSE_ = 1;
3412 GxEx(pMyDisasm);
3413 GV.SSE_ = 0;
3414 }
3415 else {
3416 FailDecode(pMyDisasm);
3417 }
3418}
3419
3420
3421/* ====================================================================
3422 * 0x 0f 38 24
3423 * ==================================================================== */
3424void __bea_callspec__ pmovsxwq_(PDISASM pMyDisasm)
3425{
3426 /* ========== 0x66 */
3427 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3428 GV.OperandSize = GV.OriginalOperandSize;
3429 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3430 GV.MemDecoration = Arg2dqword;
3431 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3432 #ifndef BEA_LIGHT_DISASSEMBLY
3433 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovsxwq ");
3434 #endif
3435 GV.SSE_ = 1;
3436 GxEx(pMyDisasm);
3437 GV.SSE_ = 0;
3438 }
3439 else {
3440 FailDecode(pMyDisasm);
3441 }
3442}
3443
3444
3445/* ====================================================================
3446 * 0x 0f 38 31
3447 * ==================================================================== */
3448void __bea_callspec__ pmovzxbd_(PDISASM pMyDisasm)
3449{
3450 /* ========== 0x66 */
3451 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3452 GV.OperandSize = GV.OriginalOperandSize;
3453 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3454 GV.MemDecoration = Arg2dqword;
3455 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3456 #ifndef BEA_LIGHT_DISASSEMBLY
3457 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxbd ");
3458 #endif
3459 GV.SSE_ = 1;
3460 GxEx(pMyDisasm);
3461 GV.SSE_ = 0;
3462 }
3463 else {
3464 FailDecode(pMyDisasm);
3465 }
3466}
3467
3468
3469/* ====================================================================
3470 * 0x 0f 38 32
3471 * ==================================================================== */
3472void __bea_callspec__ pmovzxbq_(PDISASM pMyDisasm)
3473{
3474 /* ========== 0x66 */
3475 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3476 GV.OperandSize = GV.OriginalOperandSize;
3477 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3478 GV.MemDecoration = Arg2dqword;
3479 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3480 #ifndef BEA_LIGHT_DISASSEMBLY
3481 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxbq ");
3482 #endif
3483 GV.SSE_ = 1;
3484 GxEx(pMyDisasm);
3485 GV.SSE_ = 0;
3486 }
3487 else {
3488 FailDecode(pMyDisasm);
3489 }
3490}
3491
3492
3493/* ====================================================================
3494 * 0x 0f 38 30
3495 * ==================================================================== */
3496void __bea_callspec__ pmovzxbw_(PDISASM pMyDisasm)
3497{
3498 /* ========== 0x66 */
3499 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3500 GV.OperandSize = GV.OriginalOperandSize;
3501 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3502 GV.MemDecoration = Arg2dqword;
3503 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3504 #ifndef BEA_LIGHT_DISASSEMBLY
3505 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxbw ");
3506 #endif
3507 GV.SSE_ = 1;
3508 GxEx(pMyDisasm);
3509 GV.SSE_ = 0;
3510 }
3511 else {
3512 FailDecode(pMyDisasm);
3513 }
3514}
3515
3516
3517/* ====================================================================
3518 * 0x 0f 38 35
3519 * ==================================================================== */
3520void __bea_callspec__ pmovzxdq_(PDISASM pMyDisasm)
3521{
3522 /* ========== 0x66 */
3523 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3524 GV.OperandSize = GV.OriginalOperandSize;
3525 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3526 GV.MemDecoration = Arg2dqword;
3527 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3528 #ifndef BEA_LIGHT_DISASSEMBLY
3529 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxdq ");
3530 #endif
3531 GV.SSE_ = 1;
3532 GxEx(pMyDisasm);
3533 GV.SSE_ = 0;
3534 }
3535 else {
3536 FailDecode(pMyDisasm);
3537 }
3538}
3539
3540
3541/* ====================================================================
3542 * 0x 0f 38 33
3543 * ==================================================================== */
3544void __bea_callspec__ pmovzxwd_(PDISASM pMyDisasm)
3545{
3546 /* ========== 0x66 */
3547 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3548 GV.OperandSize = GV.OriginalOperandSize;
3549 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3550 GV.MemDecoration = Arg2dqword;
3551 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3552 #ifndef BEA_LIGHT_DISASSEMBLY
3553 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxwd ");
3554 #endif
3555 GV.SSE_ = 1;
3556 GxEx(pMyDisasm);
3557 GV.SSE_ = 0;
3558 }
3559 else {
3560 FailDecode(pMyDisasm);
3561 }
3562}
3563
3564
3565/* ====================================================================
3566 * 0x 0f 38 34
3567 * ==================================================================== */
3568void __bea_callspec__ pmovzxwq_(PDISASM pMyDisasm)
3569{
3570 /* ========== 0x66 */
3571 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3572 GV.OperandSize = GV.OriginalOperandSize;
3573 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3574 GV.MemDecoration = Arg2dqword;
3575 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+CONVERSION_INSTRUCTION;
3576 #ifndef BEA_LIGHT_DISASSEMBLY
3577 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmovzxwq ");
3578 #endif
3579 GV.SSE_ = 1;
3580 GxEx(pMyDisasm);
3581 GV.SSE_ = 0;
3582 }
3583 else {
3584 FailDecode(pMyDisasm);
3585 }
3586}
3587
3588
3589/* ====================================================================
3590 * 0x 0f 38 28
3591 * ==================================================================== */
3592void __bea_callspec__ pmuldq_(PDISASM pMyDisasm)
3593{
3594 /* ========== 0x66 */
3595 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3596 GV.OperandSize = GV.OriginalOperandSize;
3597 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3598 GV.MemDecoration = Arg2dqword;
3599 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3600 #ifndef BEA_LIGHT_DISASSEMBLY
3601 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmuldq ");
3602 #endif
3603 GV.SSE_ = 1;
3604 GxEx(pMyDisasm);
3605 GV.SSE_ = 0;
3606 }
3607 else {
3608 FailDecode(pMyDisasm);
3609 }
3610}
3611
3612
3613/* ====================================================================
3614 * 0x 0f 38 40
3615 * ==================================================================== */
3616void __bea_callspec__ pmulld_(PDISASM pMyDisasm)
3617{
3618 /* ========== 0x66 */
3619 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3620 GV.OperandSize = GV.OriginalOperandSize;
3621 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3622 GV.MemDecoration = Arg2dqword;
3623 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3624 #ifndef BEA_LIGHT_DISASSEMBLY
3625 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulld ");
3626 #endif
3627 GV.SSE_ = 1;
3628 GxEx(pMyDisasm);
3629 GV.SSE_ = 0;
3630 }
3631 else {
3632 FailDecode(pMyDisasm);
3633 }
3634}
3635
3636
3637/* ====================================================================
3638 * 0x 0f 38 0b
3639 * ==================================================================== */
3640void __bea_callspec__ pmulhrsw_(PDISASM pMyDisasm)
3641{
3642 /* ========== 0x66 */
3643 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3644 GV.OperandSize = GV.OriginalOperandSize;
3645 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3646 GV.MemDecoration = Arg2dqword;
3647 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3648 #ifndef BEA_LIGHT_DISASSEMBLY
3649 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhrsw ");
3650 #endif
3651 GV.SSE_ = 1;
3652 GxEx(pMyDisasm);
3653 GV.SSE_ = 0;
3654 }
3655 else {
3656 GV.MemDecoration = Arg2qword;
3657 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+ARITHMETIC_INSTRUCTION;
3658 #ifndef BEA_LIGHT_DISASSEMBLY
3659 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhrsw ");
3660 #endif
3661 GV.MMX_ = 1;
3662 GxEx(pMyDisasm);
3663 GV.MMX_ = 0;
3664 }
3665}
3666
3667
3668/* ====================================================================
3669 * 0x 0f e4
3670 * ==================================================================== */
3671void __bea_callspec__ pmulhuw_(PDISASM pMyDisasm)
3672{
3673 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3674 /* ========== 0x66 */
3675 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3676 GV.OperandSize = GV.OriginalOperandSize;
3677 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3678 GV.MemDecoration = Arg2dqword;
3679 #ifndef BEA_LIGHT_DISASSEMBLY
3680 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhuw ");
3681 #endif
3682 GV.SSE_ = 1;
3683 GxEx(pMyDisasm);
3684 GV.SSE_ = 0;
3685 }
3686 else {
3687 GV.MemDecoration = Arg2qword;
3688 #ifndef BEA_LIGHT_DISASSEMBLY
3689 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhuw ");
3690 #endif
3691 GV.MMX_ = 1;
3692 GxEx(pMyDisasm);
3693 GV.MMX_ = 0;
3694 }
3695}
3696
3697
3698/* ====================================================================
3699 * 0x 0f f4
3700 * ==================================================================== */
3701void __bea_callspec__ pmuludq_(PDISASM pMyDisasm)
3702{
3703 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3704 /* ========== 0x66 */
3705 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3706 GV.OperandSize = GV.OriginalOperandSize;
3707 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3708 GV.MemDecoration = Arg2dqword;
3709 #ifndef BEA_LIGHT_DISASSEMBLY
3710 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmuludq ");
3711 #endif
3712 GV.SSE_ = 1;
3713 GxEx(pMyDisasm);
3714 GV.SSE_ = 0;
3715 }
3716 else {
3717 GV.MemDecoration = Arg2qword;
3718 #ifndef BEA_LIGHT_DISASSEMBLY
3719 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmuludq ");
3720 #endif
3721 GV.MMX_ = 1;
3722 GxEx(pMyDisasm);
3723 GV.MMX_ = 0;
3724 }
3725}
3726
3727
3728/* =======================================
3729 * 0x 0f b8
3730 * ======================================= */
3731void __bea_callspec__ popcnt_(PDISASM pMyDisasm)
3732{
3733 (*pMyDisasm).Instruction.Category = SSE42_INSTRUCTION+DATA_TRANSFER;
3734 #ifndef BEA_LIGHT_DISASSEMBLY
3735 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "popcnt ");
3736 #endif
3737 GvEv(pMyDisasm);
3738 FillFlags(pMyDisasm,114);
3739}
3740
3741
3742/* ====================================================================
3743 * 0x 0f f6
3744 * ==================================================================== */
3745void __bea_callspec__ psadbw_(PDISASM pMyDisasm)
3746{
3747 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SIMD64bits;
3748 /* ========== 0x66 */
3749 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3750 GV.OperandSize = GV.OriginalOperandSize;
3751 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3752 GV.MemDecoration = Arg2dqword;
3753 #ifndef BEA_LIGHT_DISASSEMBLY
3754 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psadbw ");
3755 #endif
3756 GV.SSE_ = 1;
3757 GxEx(pMyDisasm);
3758 GV.SSE_ = 0;
3759 }
3760 else {
3761 GV.MemDecoration = Arg2qword;
3762 #ifndef BEA_LIGHT_DISASSEMBLY
3763 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psadbw ");
3764 #endif
3765 GV.MMX_ = 1;
3766 GxEx(pMyDisasm);
3767 GV.MMX_ = 0;
3768 }
3769}
3770
3771
3772/* ====================================================================
3773 * 0x 0f 38 00
3774 * ==================================================================== */
3775void __bea_callspec__ pshufb_(PDISASM pMyDisasm)
3776{
3777 /* ========== 0x66 */
3778 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3779 GV.OperandSize = GV.OriginalOperandSize;
3780 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3781 GV.MemDecoration = Arg2dqword;
3782 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+SHUFFLE_UNPACK;
3783 #ifndef BEA_LIGHT_DISASSEMBLY
3784 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshufb ");
3785 #endif
3786 GV.SSE_ = 1;
3787 GxEx(pMyDisasm);
3788 GV.SSE_ = 0;
3789 }
3790 else {
3791 GV.MemDecoration = Arg2qword;
3792 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+SHUFFLE_UNPACK;
3793 #ifndef BEA_LIGHT_DISASSEMBLY
3794 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshufb ");
3795 #endif
3796 GV.MMX_ = 1;
3797 GxEx(pMyDisasm);
3798 GV.MMX_ = 0;
3799 }
3800}
3801
3802
3803/* ====================================================================
3804 * 0x 0f 70
3805 * ==================================================================== */
3806void __bea_callspec__ pshufw_(PDISASM pMyDisasm)
3807{
3808 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
3809 /* ========= 0xf3 */
3810 if (GV.PrefRepe == 1) {
3811 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
3812 GV.MemDecoration = Arg2dqword;
3813 #ifndef BEA_LIGHT_DISASSEMBLY
3814 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshufhw ");
3815 #endif
3816 GV.ImmediatSize = 8;
3817 GV.SSE_ = 1;
3818 GxEx(pMyDisasm);
3819 GV.SSE_ = 0;
3820 GV.EIP_++;
3821 if (!Security(0, pMyDisasm)) return;
3822 GV.third_arg = 1;
3823 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
3824 #ifndef BEA_LIGHT_DISASSEMBLY
3825 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
3826 #endif
3827 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
3828 (*pMyDisasm).Argument3.ArgSize = 8;
3829
3830 }
3831 /* ========= 0xf2 */
3832 else if (GV.PrefRepne == 1) {
3833 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
3834 GV.MemDecoration = Arg2dqword;
3835 #ifndef BEA_LIGHT_DISASSEMBLY
3836 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshuflw ");
3837 #endif
3838 GV.ImmediatSize = 8;
3839 GV.SSE_ = 1;
3840 GxEx(pMyDisasm);
3841 GV.SSE_ = 0;
3842 GV.EIP_++;
3843 if (!Security(0, pMyDisasm)) return;
3844 GV.third_arg = 1;
3845 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
3846 #ifndef BEA_LIGHT_DISASSEMBLY
3847 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
3848 #endif
3849 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
3850 (*pMyDisasm).Argument3.ArgSize = 8;
3851
3852 }
3853
3854 /* ========== 0x66 */
3855 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3856 GV.OperandSize = GV.OriginalOperandSize;
3857 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3858 GV.MemDecoration = Arg2dqword;
3859 #ifndef BEA_LIGHT_DISASSEMBLY
3860 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshufd ");
3861 #endif
3862 GV.ImmediatSize = 8;
3863 GV.SSE_ = 1;
3864 GxEx(pMyDisasm);
3865 GV.SSE_ = 0;
3866 GV.EIP_++;
3867 if (!Security(0, pMyDisasm)) return;
3868 GV.third_arg = 1;
3869 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
3870 #ifndef BEA_LIGHT_DISASSEMBLY
3871 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
3872 #endif
3873 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
3874 (*pMyDisasm).Argument3.ArgSize = 8;
3875
3876 }
3877 else {
3878 GV.MemDecoration = Arg2qword;
3879 #ifndef BEA_LIGHT_DISASSEMBLY
3880 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pshufw ");
3881 #endif
3882 GV.ImmediatSize = 8;
3883 GV.MMX_ = 1;
3884 GxEx(pMyDisasm);
3885 GV.MMX_ = 0;
3886 GV.EIP_++;
3887 if (!Security(0, pMyDisasm)) return;
3888 GV.third_arg = 1;
3889 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
3890 #ifndef BEA_LIGHT_DISASSEMBLY
3891 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
3892 #endif
3893 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
3894 (*pMyDisasm).Argument3.ArgSize = 8;
3895
3896 }
3897}
3898
3899/* ====================================================================
3900 * 0x 0f 38 08
3901 * ==================================================================== */
3902void __bea_callspec__ psignb_(PDISASM pMyDisasm)
3903{
3904 /* ========== 0x66 */
3905 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3906 GV.OperandSize = GV.OriginalOperandSize;
3907 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3908 GV.MemDecoration = Arg2dqword;
3909 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3910 #ifndef BEA_LIGHT_DISASSEMBLY
3911 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignb ");
3912 #endif
3913 GV.SSE_ = 1;
3914 GxEx(pMyDisasm);
3915 GV.SSE_ = 0;
3916 }
3917 else {
3918 GV.MemDecoration = Arg2qword;
3919 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3920 #ifndef BEA_LIGHT_DISASSEMBLY
3921 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignb ");
3922 #endif
3923 GV.MMX_ = 1;
3924 GxEx(pMyDisasm);
3925 GV.MMX_ = 0;
3926 }
3927}
3928
3929
3930/* ====================================================================
3931 * 0x 0f 38 0a
3932 * ==================================================================== */
3933void __bea_callspec__ psignd_(PDISASM pMyDisasm)
3934{
3935 /* ========== 0x66 */
3936 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3937 GV.OperandSize = GV.OriginalOperandSize;
3938 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3939 GV.MemDecoration = Arg2dqword;
3940 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3941 #ifndef BEA_LIGHT_DISASSEMBLY
3942 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignd ");
3943 #endif
3944 GV.SSE_ = 1;
3945 GxEx(pMyDisasm);
3946 GV.SSE_ = 0;
3947 }
3948 else {
3949 GV.MemDecoration = Arg2qword;
3950 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3951 #ifndef BEA_LIGHT_DISASSEMBLY
3952 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignd ");
3953 #endif
3954 GV.MMX_ = 1;
3955 GxEx(pMyDisasm);
3956 GV.MMX_ = 0;
3957 }
3958}
3959
3960
3961/* ====================================================================
3962 * 0x 0f 38 09
3963 * ==================================================================== */
3964void __bea_callspec__ psignw_(PDISASM pMyDisasm)
3965{
3966 /* ========== 0x66 */
3967 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3968 GV.OperandSize = GV.OriginalOperandSize;
3969 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
3970 GV.MemDecoration = Arg2dqword;
3971 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3972 #ifndef BEA_LIGHT_DISASSEMBLY
3973 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignw ");
3974 #endif
3975 GV.SSE_ = 1;
3976 GxEx(pMyDisasm);
3977 GV.SSE_ = 0;
3978 }
3979 else {
3980 GV.MemDecoration = Arg2qword;
3981 (*pMyDisasm).Instruction.Category = SSSE3_INSTRUCTION+PACKED_SIGN;
3982 #ifndef BEA_LIGHT_DISASSEMBLY
3983 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psignw ");
3984 #endif
3985 GV.MMX_ = 1;
3986 GxEx(pMyDisasm);
3987 GV.MMX_ = 0;
3988 }
3989}
3990
3991
3992/* ====================================================================
3993 * 0x 0f fb
3994 * ==================================================================== */
3995void __bea_callspec__ psubq_(PDISASM pMyDisasm)
3996{
3997 /* ========== 0x66 */
3998 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
3999 GV.OperandSize = GV.OriginalOperandSize;
4000 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4001 GV.MemDecoration = Arg2dqword;
4002 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
4003 #ifndef BEA_LIGHT_DISASSEMBLY
4004 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubq ");
4005 #endif
4006 GV.SSE_ = 1;
4007 GxEx(pMyDisasm);
4008 GV.SSE_ = 0;
4009 }
4010 else {
4011 GV.MemDecoration = Arg2qword;
4012 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
4013 #ifndef BEA_LIGHT_DISASSEMBLY
4014 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubq ");
4015 #endif
4016 GV.MMX_ = 1;
4017 GxEx(pMyDisasm);
4018 GV.MMX_ = 0;
4019 }
4020}
4021
4022
4023/* ====================================================================
4024 * 0x 0f 38 17
4025 * ==================================================================== */
4026void __bea_callspec__ ptest_(PDISASM pMyDisasm)
4027{
4028 /* ========== 0x66 */
4029 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4030 GV.OperandSize = GV.OriginalOperandSize;
4031 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4032 GV.MemDecoration = Arg2dqword;
4033 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+PACKED_TEST;
4034 #ifndef BEA_LIGHT_DISASSEMBLY
4035 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ptest ");
4036 #endif
4037 GV.SSE_ = 1;
4038 GxEx(pMyDisasm);
4039 GV.SSE_ = 0;
4040 }
4041 else {
4042 FailDecode(pMyDisasm);
4043 }
4044
4045}
4046
4047/* ====================================================================
4048 * 0x 0f 6c
4049 * ==================================================================== */
4050void __bea_callspec__ punpcklqdq_(PDISASM pMyDisasm)
4051{
4052 /* ========== 0x66 */
4053 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4054 GV.OperandSize = GV.OriginalOperandSize;
4055 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4056 GV.MemDecoration = Arg2dqword;
4057 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
4058 #ifndef BEA_LIGHT_DISASSEMBLY
4059 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklqdq ");
4060 #endif
4061 GV.SSE_ = 1;
4062 GxEx(pMyDisasm);
4063 GV.SSE_ = 0;
4064 }
4065 else {
4066 FailDecode(pMyDisasm);
4067 }
4068
4069}
4070
4071/* ====================================================================
4072 * 0x 0f 6d
4073 * ==================================================================== */
4074void __bea_callspec__ punpckhqdq_(PDISASM pMyDisasm)
4075{
4076 /* ========== 0x66 */
4077 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4078 GV.OperandSize = GV.OriginalOperandSize;
4079 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4080 GV.MemDecoration = Arg2dqword;
4081 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SIMD128bits;
4082 #ifndef BEA_LIGHT_DISASSEMBLY
4083 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhqdq ");
4084 #endif
4085 GV.SSE_ = 1;
4086 GxEx(pMyDisasm);
4087 GV.SSE_ = 0;
4088 }
4089 else {
4090 FailDecode(pMyDisasm);
4091 }
4092
4093}
4094
4095
4096/* ====================================================================
4097 * 0x 0f 53
4098 * ==================================================================== */
4099void __bea_callspec__ rcpps_(PDISASM pMyDisasm)
4100{
4101 /* ========== 0xf3 */
4102 if (GV.PrefRepe == 1) {
4103 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
4104 GV.MemDecoration = Arg2dword;
4105 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4106 #ifndef BEA_LIGHT_DISASSEMBLY
4107 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcpss ");
4108 #endif
4109 GV.SSE_ = 1;
4110 GxEx(pMyDisasm);
4111 GV.SSE_ = 0;
4112 }
4113 else {
4114 GV.MemDecoration = Arg2dqword;
4115 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4116 #ifndef BEA_LIGHT_DISASSEMBLY
4117 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rcpps ");
4118 #endif
4119 GV.SSE_ = 1;
4120 GxEx(pMyDisasm);
4121 GV.SSE_ = 0;
4122 }
4123}
4124
4125
4126/* ====================================================================
4127 * 0x 0f 3a 09
4128 * ==================================================================== */
4129void __bea_callspec__ roundpd_(PDISASM pMyDisasm)
4130{
4131 /* ========== 0x66 */
4132 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4133 GV.OperandSize = GV.OriginalOperandSize;
4134 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4135 GV.MemDecoration = Arg2dqword;
4136 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ROUND_INSTRUCTION;
4137 #ifndef BEA_LIGHT_DISASSEMBLY
4138 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "roundpd ");
4139 #endif
4140 GV.ImmediatSize = 8;
4141 GV.SSE_ = 1;
4142 GxEx(pMyDisasm);
4143 GV.SSE_ = 0;
4144 GV.EIP_++;
4145 if (!Security(0, pMyDisasm)) return;
4146 GV.third_arg = 1;
4147 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
4148 #ifndef BEA_LIGHT_DISASSEMBLY
4149 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
4150 #endif
4151 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
4152 (*pMyDisasm).Argument3.ArgSize = 8;
4153
4154 }
4155 else {
4156 FailDecode(pMyDisasm);
4157 }
4158}
4159
4160
4161/* ====================================================================
4162 * 0x 0f 3a 08
4163 * ==================================================================== */
4164void __bea_callspec__ roundps_(PDISASM pMyDisasm)
4165{
4166 /* ========== 0x66 */
4167 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4168 GV.OperandSize = GV.OriginalOperandSize;
4169 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4170 GV.MemDecoration = Arg2dqword;
4171 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ROUND_INSTRUCTION;
4172 #ifndef BEA_LIGHT_DISASSEMBLY
4173 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "roundps ");
4174 #endif
4175 GV.ImmediatSize = 8;
4176 GV.SSE_ = 1;
4177 GxEx(pMyDisasm);
4178 GV.SSE_ = 0;
4179 GV.EIP_++;
4180 if (!Security(0, pMyDisasm)) return;
4181 GV.third_arg = 1;
4182 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
4183 #ifndef BEA_LIGHT_DISASSEMBLY
4184 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
4185 #endif
4186 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
4187 (*pMyDisasm).Argument3.ArgSize = 8;
4188
4189 }
4190 else {
4191 FailDecode(pMyDisasm);
4192 }
4193}
4194
4195
4196/* ====================================================================
4197 * 0x 0f 3a 0b
4198 * ==================================================================== */
4199void __bea_callspec__ roundsd_(PDISASM pMyDisasm)
4200{
4201 /* ========== 0x66 */
4202 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4203 GV.OperandSize = GV.OriginalOperandSize;
4204 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4205 GV.MemDecoration = Arg2dqword;
4206 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ROUND_INSTRUCTION;
4207 #ifndef BEA_LIGHT_DISASSEMBLY
4208 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "roundsd ");
4209 #endif
4210 GV.ImmediatSize = 8;
4211 GV.SSE_ = 1;
4212 GxEx(pMyDisasm);
4213 GV.SSE_ = 0;
4214 GV.EIP_++;
4215 if (!Security(0, pMyDisasm)) return;
4216 GV.third_arg = 1;
4217 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
4218 #ifndef BEA_LIGHT_DISASSEMBLY
4219 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
4220 #endif
4221 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
4222 (*pMyDisasm).Argument3.ArgSize = 8;
4223
4224 }
4225 else {
4226 FailDecode(pMyDisasm);
4227 }
4228}
4229
4230
4231/* ====================================================================
4232 * 0x 0f 3a 0a
4233 * ==================================================================== */
4234void __bea_callspec__ roundss_(PDISASM pMyDisasm)
4235{
4236 /* ========== 0x66 */
4237 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4238 GV.OperandSize = GV.OriginalOperandSize;
4239 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4240 GV.MemDecoration = Arg2dword;
4241 (*pMyDisasm).Instruction.Category = SSE41_INSTRUCTION+ROUND_INSTRUCTION;
4242 #ifndef BEA_LIGHT_DISASSEMBLY
4243 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "roundss ");
4244 #endif
4245 GV.ImmediatSize = 8;
4246 GV.SSE_ = 1;
4247 GxEx(pMyDisasm);
4248 GV.SSE_ = 0;
4249 GV.EIP_++;
4250 if (!Security(0, pMyDisasm)) return;
4251 GV.third_arg = 1;
4252 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
4253 #ifndef BEA_LIGHT_DISASSEMBLY
4254 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
4255 #endif
4256 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
4257 (*pMyDisasm).Argument3.ArgSize = 8;
4258
4259 }
4260 else {
4261 FailDecode(pMyDisasm);
4262 }
4263}
4264
4265
4266/* ====================================================================
4267 * 0x 0f 52
4268 * ==================================================================== */
4269void __bea_callspec__ rsqrtps_(PDISASM pMyDisasm)
4270{
4271 /* ========== 0xf3 */
4272 if (GV.PrefRepe == 1) {
4273 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
4274 GV.MemDecoration = Arg2dword;
4275 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4276 #ifndef BEA_LIGHT_DISASSEMBLY
4277 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rsqrtss ");
4278 #endif
4279 GV.SSE_ = 1;
4280 GxEx(pMyDisasm);
4281 GV.SSE_ = 0;
4282 }
4283 else {
4284 GV.MemDecoration = Arg2dqword;
4285 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4286 #ifndef BEA_LIGHT_DISASSEMBLY
4287 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "rsqrtps ");
4288 #endif
4289 GV.SSE_ = 1;
4290 GxEx(pMyDisasm);
4291 GV.SSE_ = 0;
4292 }
4293}
4294
4295
4296/* ====================================================================
4297 * 0x 0f c6
4298 * ==================================================================== */
4299void __bea_callspec__ shufps_(PDISASM pMyDisasm)
4300{
4301
4302 /* ========== 0x66 */
4303 GV.ImmediatSize = 8;
4304 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4305 GV.OperandSize = GV.OriginalOperandSize;
4306 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4307 GV.MemDecoration = Arg2dqword;
4308 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
4309 #ifndef BEA_LIGHT_DISASSEMBLY
4310 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shufpd ");
4311 #endif
4312 GV.SSE_ = 1;
4313 GxEx(pMyDisasm);
4314 GV.SSE_ = 0;
4315 }
4316 else {
4317 GV.MemDecoration = Arg2dqword;
4318 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+SHUFFLE_UNPACK;
4319 #ifndef BEA_LIGHT_DISASSEMBLY
4320 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "shufps ");
4321 #endif
4322 GV.SSE_ = 1;
4323 GxEx(pMyDisasm);
4324 GV.SSE_ = 0;
4325 }
4326 (*pMyDisasm).Argument1.AccessMode = READ;
4327 GV.EIP_++;
4328 if (!Security(0, pMyDisasm)) return;
4329 GV.third_arg = 1;
4330 (*pMyDisasm).Instruction.Immediat = *((UInt8*)(UIntPtr) (GV.EIP_- 1));
4331 #ifndef BEA_LIGHT_DISASSEMBLY
4332 (void) CopyFormattedNumber(pMyDisasm, (char*) (*pMyDisasm).Argument3.ArgMnemonic, "%.2X",(Int64) *((UInt8*)(UIntPtr) (GV.EIP_- 1)));
4333 #endif
4334 (*pMyDisasm).Argument3.ArgType = CONSTANT_TYPE+ABSOLUTE_;
4335 (*pMyDisasm).Argument3.ArgSize = 8;
4336
4337}
4338
4339
4340/* ====================================================================
4341 * 0x 0f 51
4342 * ==================================================================== */
4343void __bea_callspec__ sqrtps_VW(PDISASM pMyDisasm)
4344{
4345 /* ========= 0xf2 */
4346 if (GV.PrefRepne == 1) {
4347 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
4348 GV.MemDecoration = Arg2qword;
4349 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4350 #ifndef BEA_LIGHT_DISASSEMBLY
4351 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sqrtsd ");
4352 #endif
4353 GV.SSE_ = 1;
4354 GxEx(pMyDisasm);
4355 GV.SSE_ = 0;
4356 }
4357 /* ========= 0xf3 */
4358 else if (GV.PrefRepe == 1) {
4359 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
4360 GV.MemDecoration = Arg2dword;
4361 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4362 #ifndef BEA_LIGHT_DISASSEMBLY
4363 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sqrtss ");
4364 #endif
4365 GV.SSE_ = 1;
4366 GxEx(pMyDisasm);
4367 GV.SSE_ = 0;
4368 }
4369 /* ========== 0x66 */
4370 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4371 GV.OperandSize = GV.OriginalOperandSize;
4372 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4373 GV.MemDecoration = Arg2dqword;
4374 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4375 #ifndef BEA_LIGHT_DISASSEMBLY
4376 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sqrtpd ");
4377 #endif
4378 GV.SSE_ = 1;
4379 GxEx(pMyDisasm);
4380 GV.SSE_ = 0;
4381 }
4382 else {
4383 GV.MemDecoration = Arg2dqword;
4384 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4385 #ifndef BEA_LIGHT_DISASSEMBLY
4386 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "sqrtps ");
4387 #endif
4388 GV.SSE_ = 1;
4389 GxEx(pMyDisasm);
4390 GV.SSE_ = 0;
4391 }
4392}
4393
4394
4395/* ====================================================================
4396 * 0x 0f 5c
4397 * ==================================================================== */
4398void __bea_callspec__ subps_VW(PDISASM pMyDisasm)
4399{
4400 /* ========= 0xf2 */
4401 if (GV.PrefRepne == 1) {
4402 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
4403 GV.MemDecoration = Arg2qword;
4404 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4405 #ifndef BEA_LIGHT_DISASSEMBLY
4406 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "subsd ");
4407 #endif
4408 GV.SSE_ = 1;
4409 GxEx(pMyDisasm);
4410 GV.SSE_ = 0;
4411 }
4412 /* ========= 0xf3 */
4413 else if (GV.PrefRepe == 1) {
4414 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
4415 GV.MemDecoration = Arg2dword;
4416 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4417 #ifndef BEA_LIGHT_DISASSEMBLY
4418 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "subss ");
4419 #endif
4420 GV.SSE_ = 1;
4421 GxEx(pMyDisasm);
4422 GV.SSE_ = 0;
4423 }
4424 /* ========== 0x66 */
4425 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4426 GV.OperandSize = GV.OriginalOperandSize;
4427 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4428 GV.MemDecoration = Arg2dqword;
4429 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4430 #ifndef BEA_LIGHT_DISASSEMBLY
4431 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "subpd ");
4432 #endif
4433 GV.SSE_ = 1;
4434 GxEx(pMyDisasm);
4435 GV.SSE_ = 0;
4436 }
4437 else {
4438 GV.MemDecoration = Arg2dqword;
4439 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+ARITHMETIC_INSTRUCTION;
4440 #ifndef BEA_LIGHT_DISASSEMBLY
4441 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "subps ");
4442 #endif
4443 GV.SSE_ = 1;
4444 GxEx(pMyDisasm);
4445 GV.SSE_ = 0;
4446 }
4447}
4448
4449
4450/* ====================================================================
4451 * 0x 0f 2e
4452 * ==================================================================== */
4453void __bea_callspec__ ucomiss_VW(PDISASM pMyDisasm)
4454{
4455 /* ========== 0x66 */
4456 if (GV.OperandSize == 16) {
4457 GV.OperandSize = GV.OriginalOperandSize;
4458 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4459 GV.MemDecoration = Arg2dword;
4460 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+COMPARISON_INSTRUCTION;
4461 #ifndef BEA_LIGHT_DISASSEMBLY
4462 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ucomisd ");
4463 #endif
4464 GV.SSE_ = 1;
4465 GxEx(pMyDisasm);
4466 GV.SSE_ = 0;
4467 }
4468 else {
4469 GV.MemDecoration = Arg2dqword;
4470 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+COMPARISON_INSTRUCTION;
4471 #ifndef BEA_LIGHT_DISASSEMBLY
4472 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "ucomiss ");
4473 #endif
4474 GV.SSE_ = 1;
4475 GxEx(pMyDisasm);
4476 GV.SSE_ = 0;
4477 }
4478}
4479
4480
4481/* ====================================================================
4482 * 0x 0f 15
4483 * ==================================================================== */
4484void __bea_callspec__ unpckhps_(PDISASM pMyDisasm)
4485{
4486 /* ========== 0x66 */
4487 if (GV.OperandSize == 16) {
4488 GV.OperandSize = GV.OriginalOperandSize;
4489 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4490 GV.MemDecoration = Arg2dqword;
4491 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
4492 #ifndef BEA_LIGHT_DISASSEMBLY
4493 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpckhpd ");
4494 #endif
4495 GV.SSE_ = 1;
4496 GxEx(pMyDisasm);
4497 GV.SSE_ = 0;
4498 }
4499 else {
4500 GV.MemDecoration = Arg2dqword;
4501 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
4502 #ifndef BEA_LIGHT_DISASSEMBLY
4503 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpckhps ");
4504 #endif
4505 GV.SSE_ = 1;
4506 GxEx(pMyDisasm);
4507 GV.SSE_ = 0;
4508 }
4509}
4510
4511/* ====================================================================
4512 * 0x 0f 14
4513 * ==================================================================== */
4514void __bea_callspec__ unpcklps_(PDISASM pMyDisasm)
4515{
4516 /* ========== 0x66 */
4517 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4518 GV.OperandSize = GV.OriginalOperandSize;
4519 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4520 GV.MemDecoration = Arg2dqword;
4521 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
4522 #ifndef BEA_LIGHT_DISASSEMBLY
4523 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpcklpd ");
4524 #endif
4525 GV.SSE_ = 1;
4526 GxEx(pMyDisasm);
4527 GV.SSE_ = 0;
4528 }
4529 else {
4530 GV.MemDecoration = Arg2dqword;
4531 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+SHUFFLE_UNPACK;
4532 #ifndef BEA_LIGHT_DISASSEMBLY
4533 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "unpcklps ");
4534 #endif
4535 GV.SSE_ = 1;
4536 GxEx(pMyDisasm);
4537 GV.SSE_ = 0;
4538 }
4539}
4540
4541
4542/* ====================================================================
4543 * 0x 0f 57
4544 * ==================================================================== */
4545void __bea_callspec__ xorps_VW(PDISASM pMyDisasm)
4546{
4547 /* ========== 0x66 */
4548 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
4549 GV.OperandSize = GV.OriginalOperandSize;
4550 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
4551 GV.MemDecoration = Arg2dqword;
4552 (*pMyDisasm).Instruction.Category = SSE2_INSTRUCTION+LOGICAL_INSTRUCTION;
4553 #ifndef BEA_LIGHT_DISASSEMBLY
4554 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xorpd ");
4555 #endif
4556 GV.SSE_ = 1;
4557 GxEx(pMyDisasm);
4558 GV.SSE_ = 0;
4559 }
4560 else {
4561 GV.MemDecoration = Arg2dqword;
4562 (*pMyDisasm).Instruction.Category = SSE_INSTRUCTION+LOGICAL_INSTRUCTION;
4563 #ifndef BEA_LIGHT_DISASSEMBLY
4564 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "xorps ");
4565 #endif
4566 GV.SSE_ = 1;
4567 GxEx(pMyDisasm);
4568 GV.SSE_ = 0;
4569 }
4570}
Note: See TracBrowser for help on using the repository browser.