source: Daodan/src/beaengine/Includes/instr_set/opcodes_MMX.c@ 1024

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

Daodan: TV code
File size: 60.2 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
19void __bea_callspec__ emms_(PDISASM pMyDisasm)
20{
21 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+STATE_MANAGEMENT;
22 #ifndef BEA_LIGHT_DISASSEMBLY
23 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "emms ");
24 #endif
25 GV.EIP_++;
26}
27
28/* ====================================================================
29 * 0x 0f 7e
30 * ==================================================================== */
31void __bea_callspec__ movd_EP(PDISASM pMyDisasm)
32{
33 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
34 /* ========= 0xf3 */
35 if (GV.PrefRepe == 1) {
36 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
37 GV.MemDecoration = Arg2qword;
38 #ifndef BEA_LIGHT_DISASSEMBLY
39 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
40 #endif
41 GV.SSE_ = 1;
42 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
43 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
44 GV.SSE_ = 0;
45 GV.EIP_+= GV.DECALAGE_EIP+2;
46 }
47 /* ========== 0x66 */
48 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
49 GV.OperandSize = GV.OriginalOperandSize;
50 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
51 if (GV.REX.W_ == 1) {
52 GV.MemDecoration = Arg1qword;
53 #ifndef BEA_LIGHT_DISASSEMBLY
54 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
55 #endif
56 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
57 GV.SSE_ = 1;
58 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
59 GV.SSE_ = 0;
60 GV.EIP_+= GV.DECALAGE_EIP+2;
61 }
62 else {
63 GV.MemDecoration = Arg1dword;
64 #ifndef BEA_LIGHT_DISASSEMBLY
65 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movd ");
66 #endif
67 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
68 GV.SSE_ = 1;
69 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
70 GV.SSE_ = 0;
71 GV.EIP_+= GV.DECALAGE_EIP+2;
72 }
73 }
74 else {
75 if (GV.REX.W_ == 1) {
76 GV.MemDecoration = Arg1qword;
77 #ifndef BEA_LIGHT_DISASSEMBLY
78 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
79 #endif
80 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
81 GV.MMX_ = 1;
82 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
83 GV.MMX_ = 0;
84 GV.EIP_+= GV.DECALAGE_EIP+2;
85 }
86 else {
87 GV.MemDecoration = Arg1dword;
88 #ifndef BEA_LIGHT_DISASSEMBLY
89 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movd ");
90 #endif
91 MOD_RM(&(*pMyDisasm).Argument1, pMyDisasm);
92 GV.MMX_ = 1;
93 Reg_Opcode(&(*pMyDisasm).Argument2, pMyDisasm);
94 GV.MMX_ = 0;
95 GV.EIP_+= GV.DECALAGE_EIP+2;
96 }
97 }
98}
99
100
101/* ====================================================================
102 * 0x 0f 6e
103 * ==================================================================== */
104void __bea_callspec__ movd_PE(PDISASM pMyDisasm)
105{
106 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
107 /* ========== 0x66 */
108 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
109 GV.OperandSize = GV.OriginalOperandSize;
110 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
111 if (GV.REX.W_ == 1) {
112 GV.MemDecoration = Arg2qword;
113 #ifndef BEA_LIGHT_DISASSEMBLY
114 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
115 #endif
116 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
117 GV.SSE_ = 1;
118 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
119 GV.SSE_ = 0;
120 GV.EIP_+= GV.DECALAGE_EIP+2;
121 }
122 else {
123 GV.MemDecoration = Arg2dword;
124 #ifndef BEA_LIGHT_DISASSEMBLY
125 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movd ");
126 #endif
127 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
128 GV.SSE_ = 1;
129 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
130 GV.SSE_ = 0;
131 GV.EIP_+= GV.DECALAGE_EIP+2;
132 }
133 }
134 else {
135 if (GV.REX.W_ == 1) {
136 GV.MemDecoration = Arg2qword;
137 #ifndef BEA_LIGHT_DISASSEMBLY
138 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
139 #endif
140 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
141 GV.MMX_ = 1;
142 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
143 GV.MMX_ = 0;
144 GV.EIP_+= GV.DECALAGE_EIP+2;
145 }
146 else {
147 GV.MemDecoration = Arg2dword;
148 #ifndef BEA_LIGHT_DISASSEMBLY
149 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movd ");
150 #endif
151 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
152 GV.MMX_ = 1;
153 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
154 GV.MMX_ = 0;
155 GV.EIP_+= GV.DECALAGE_EIP+2;
156 }
157 }
158}
159
160
161
162/* ====================================================================
163 * 0x 0f 6f
164 * ==================================================================== */
165void __bea_callspec__ movq_PQ(PDISASM pMyDisasm)
166{
167 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
168 /* ========= 0xf3 */
169 if (GV.PrefRepe == 1) {
170 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
171 GV.MemDecoration = Arg2dqword;
172 #ifndef BEA_LIGHT_DISASSEMBLY
173 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqu ");
174 #endif
175 GV.SSE_ = 1;
176 GxEx(pMyDisasm);
177 GV.SSE_ = 0;
178 }
179 /* ========== 0x66 */
180 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
181 GV.OperandSize = GV.OriginalOperandSize;
182 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
183 GV.MemDecoration = Arg2dqword;
184 #ifndef BEA_LIGHT_DISASSEMBLY
185 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqa ");
186 #endif
187 GV.SSE_ = 1;
188 GxEx(pMyDisasm);
189 GV.SSE_ = 0;
190 }
191 else {
192 GV.MemDecoration = Arg2qword;
193 #ifndef BEA_LIGHT_DISASSEMBLY
194 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
195 #endif
196 GV.MMX_ = 1;
197 GxEx(pMyDisasm);
198 GV.MMX_ = 0;
199 }
200}
201
202
203/* ====================================================================
204 * 0x 0f 7f
205 * ==================================================================== */
206void __bea_callspec__ movq_QP(PDISASM pMyDisasm)
207{
208 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
209 /* ========= 0xf3 */
210 if (GV.PrefRepe == 1) {
211 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
212 GV.MemDecoration = Arg1dqword;
213 #ifndef BEA_LIGHT_DISASSEMBLY
214 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqu ");
215 #endif
216 GV.SSE_ = 1;
217 ExGx(pMyDisasm);
218 GV.SSE_ = 0;
219 }
220 /* ========== 0x66 */
221 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
222 GV.OperandSize = GV.OriginalOperandSize;
223 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
224 GV.MemDecoration = Arg1dqword;
225 #ifndef BEA_LIGHT_DISASSEMBLY
226 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdqa ");
227 #endif
228 GV.SSE_ = 1;
229 ExGx(pMyDisasm);
230 GV.SSE_ = 0;
231 }
232 else {
233 GV.MemDecoration = Arg1qword;
234 #ifndef BEA_LIGHT_DISASSEMBLY
235 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
236 #endif
237 GV.MMX_ = 1;
238 ExGx(pMyDisasm);
239 GV.MMX_ = 0;
240 }
241}
242
243/* ====================================================================
244 * 0x 0f d6
245 * ==================================================================== */
246void __bea_callspec__ movq_WV(PDISASM pMyDisasm)
247{
248 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+DATA_TRANSFER;
249 /* ========= 0xf2 */
250 if (GV.PrefRepne == 1) {
251 (*pMyDisasm).Prefix.RepnePrefix = MandatoryPrefix;
252 GV.MemDecoration = Arg2dqword;
253 #ifndef BEA_LIGHT_DISASSEMBLY
254 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movdq2q ");
255 #endif
256 GV.MMX_ = 1;
257 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
258 GV.MMX_ = 0;
259 GV.SSE_ = 1;
260 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
261 GV.SSE_ = 0;
262 GV.EIP_+= GV.DECALAGE_EIP+2;
263
264 }
265 /* ========= 0xf3 */
266 else if (GV.PrefRepe == 1) {
267 (*pMyDisasm).Prefix.RepPrefix = MandatoryPrefix;
268 GV.MemDecoration = Arg2qword;
269 #ifndef BEA_LIGHT_DISASSEMBLY
270 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq2dq ");
271 #endif
272 GV.SSE_ = 1;
273 Reg_Opcode(&(*pMyDisasm).Argument1, pMyDisasm);
274 GV.SSE_ = 0;
275 GV.MMX_ = 1;
276 MOD_RM(&(*pMyDisasm).Argument2, pMyDisasm);
277 GV.MMX_ = 0;
278 GV.EIP_+= GV.DECALAGE_EIP+2;
279 }
280 /* ========== 0x66 */
281 else if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
282 GV.OperandSize = GV.OriginalOperandSize;
283 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
284 GV.MemDecoration = Arg1qword;
285 #ifndef BEA_LIGHT_DISASSEMBLY
286 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "movq ");
287 #endif
288 GV.SSE_ = 1;
289 ExGx(pMyDisasm);
290 GV.SSE_ = 0;
291 }
292 else {
293 FailDecode(pMyDisasm);
294 }
295}
296
297
298/* ====================================================================
299 * 0x 0f 38 1c
300 * ==================================================================== */
301void __bea_callspec__ pabsb_(PDISASM pMyDisasm)
302{
303 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
304 /* ========== 0x66 */
305 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
306 GV.OperandSize = GV.OriginalOperandSize;
307 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
308 GV.MemDecoration = Arg2dqword;
309 #ifndef BEA_LIGHT_DISASSEMBLY
310 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsb ");
311 #endif
312 GV.SSE_ = 1;
313 GxEx(pMyDisasm);
314 GV.SSE_ = 0;
315 }
316 else {
317 GV.MemDecoration = Arg2qword;
318 #ifndef BEA_LIGHT_DISASSEMBLY
319 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsb ");
320 #endif
321 GV.MMX_ = 1;
322 GxEx(pMyDisasm);
323 GV.MMX_ = 0;
324 }
325}
326
327/* ====================================================================
328 * 0x 0f 38 1e
329 * ==================================================================== */
330void __bea_callspec__ pabsd_(PDISASM pMyDisasm)
331{
332 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
333 /* ========== 0x66 */
334 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
335 GV.OperandSize = GV.OriginalOperandSize;
336 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
337 GV.MemDecoration = Arg2dqword;
338 #ifndef BEA_LIGHT_DISASSEMBLY
339 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsd ");
340 #endif
341 GV.SSE_ = 1;
342 GxEx(pMyDisasm);
343 GV.SSE_ = 0;
344 }
345 else {
346 GV.MemDecoration = Arg2qword;
347 #ifndef BEA_LIGHT_DISASSEMBLY
348 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsd ");
349 #endif
350 GV.MMX_ = 1;
351 GxEx(pMyDisasm);
352 GV.MMX_ = 0;
353 }
354}
355
356/* ====================================================================
357 * 0x 0f 38 1d
358 * ==================================================================== */
359void __bea_callspec__ pabsw_(PDISASM pMyDisasm)
360{
361 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
362 /* ========== 0x66 */
363 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
364 GV.OperandSize = GV.OriginalOperandSize;
365 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
366 GV.MemDecoration = Arg2dqword;
367 #ifndef BEA_LIGHT_DISASSEMBLY
368 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsw ");
369 #endif
370 GV.SSE_ = 1;
371 GxEx(pMyDisasm);
372 GV.SSE_ = 0;
373 }
374 else {
375 GV.MemDecoration = Arg2qword;
376 #ifndef BEA_LIGHT_DISASSEMBLY
377 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pabsw ");
378 #endif
379 GV.MMX_ = 1;
380 GxEx(pMyDisasm);
381 GV.MMX_ = 0;
382 }
383}
384
385/* ====================================================================
386 * 0x 0f 63
387 * ==================================================================== */
388void __bea_callspec__ packsswb_(PDISASM pMyDisasm)
389{
390 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
391 /* ========== 0x66 */
392 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
393 GV.OperandSize = GV.OriginalOperandSize;
394 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
395 GV.MemDecoration = Arg2dqword;
396 #ifndef BEA_LIGHT_DISASSEMBLY
397 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packsswb ");
398 #endif
399 GV.SSE_ = 1;
400 GxEx(pMyDisasm);
401 GV.SSE_ = 0;
402 }
403 else {
404 GV.MemDecoration = Arg2qword;
405 #ifndef BEA_LIGHT_DISASSEMBLY
406 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packsswb ");
407 #endif
408 GV.MMX_ = 1;
409 GxEx(pMyDisasm);
410 GV.MMX_ = 0;
411 }
412}
413
414/* ====================================================================
415 * 0x 0f 6b
416 * ==================================================================== */
417void __bea_callspec__ packssdw_(PDISASM pMyDisasm)
418{
419 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
420 /* ========== 0x66 */
421 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
422 GV.OperandSize = GV.OriginalOperandSize;
423 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
424 GV.MemDecoration = Arg2dqword;
425 #ifndef BEA_LIGHT_DISASSEMBLY
426 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packssdw ");
427 #endif
428 GV.SSE_ = 1;
429 GxEx(pMyDisasm);
430 GV.SSE_ = 0;
431 }
432 else {
433 GV.MemDecoration = Arg2qword;
434 #ifndef BEA_LIGHT_DISASSEMBLY
435 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packssdw ");
436 #endif
437 GV.MMX_ = 1;
438 GxEx(pMyDisasm);
439 GV.MMX_ = 0;
440 }
441}
442
443/* ====================================================================
444 * 0x 0f 67
445 * ==================================================================== */
446void __bea_callspec__ packuswb_(PDISASM pMyDisasm)
447{
448 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
449 /* ========== 0x66 */
450 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
451 GV.OperandSize = GV.OriginalOperandSize;
452 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
453 GV.MemDecoration = Arg2dqword;
454 #ifndef BEA_LIGHT_DISASSEMBLY
455 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packuswb ");
456 #endif
457 GV.SSE_ = 1;
458 GxEx(pMyDisasm);
459 GV.SSE_ = 0;
460 }
461 else {
462 GV.MemDecoration = Arg2qword;
463 #ifndef BEA_LIGHT_DISASSEMBLY
464 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "packuswb ");
465 #endif
466 GV.MMX_ = 1;
467 GxEx(pMyDisasm);
468 GV.MMX_ = 0;
469 }
470}
471
472/* ====================================================================
473 * 0x 0f fc
474 * ==================================================================== */
475void __bea_callspec__ paddb_(PDISASM pMyDisasm)
476{
477 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
478 /* ========== 0x66 */
479 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
480 GV.OperandSize = GV.OriginalOperandSize;
481 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
482 GV.MemDecoration = Arg2dqword;
483 #ifndef BEA_LIGHT_DISASSEMBLY
484 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddb ");
485 #endif
486 GV.SSE_ = 1;
487 GxEx(pMyDisasm);
488 GV.SSE_ = 0;
489 }
490 else {
491 GV.MemDecoration = Arg2qword;
492 #ifndef BEA_LIGHT_DISASSEMBLY
493 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddb ");
494 #endif
495 GV.MMX_ = 1;
496 GxEx(pMyDisasm);
497 GV.MMX_ = 0;
498 }
499}
500
501/* ====================================================================
502 * 0x 0f fd
503 * ==================================================================== */
504void __bea_callspec__ paddw_(PDISASM pMyDisasm)
505{
506 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
507 /* ========== 0x66 */
508 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
509 GV.OperandSize = GV.OriginalOperandSize;
510 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
511 GV.MemDecoration = Arg2dqword;
512 #ifndef BEA_LIGHT_DISASSEMBLY
513 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddw ");
514 #endif
515 GV.SSE_ = 1;
516 GxEx(pMyDisasm);
517 GV.SSE_ = 0;
518 }
519 else {
520 GV.MemDecoration = Arg2qword;
521 #ifndef BEA_LIGHT_DISASSEMBLY
522 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddw ");
523 #endif
524 GV.MMX_ = 1;
525 GxEx(pMyDisasm);
526 GV.MMX_ = 0;
527 }
528}
529
530/* ====================================================================
531 * 0x 0f fe
532 * ==================================================================== */
533void __bea_callspec__ paddd_(PDISASM pMyDisasm)
534{
535 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
536 /* ========== 0x66 */
537 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
538 GV.OperandSize = GV.OriginalOperandSize;
539 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
540 GV.MemDecoration = Arg2dqword;
541 #ifndef BEA_LIGHT_DISASSEMBLY
542 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddd ");
543 #endif
544 GV.SSE_ = 1;
545 GxEx(pMyDisasm);
546 GV.SSE_ = 0;
547 }
548 else {
549 GV.MemDecoration = Arg2qword;
550 #ifndef BEA_LIGHT_DISASSEMBLY
551 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddd ");
552 #endif
553 GV.MMX_ = 1;
554 GxEx(pMyDisasm);
555 GV.MMX_ = 0;
556 }
557}
558
559/* ====================================================================
560 * 0x 0f ec
561 * ==================================================================== */
562void __bea_callspec__ paddsb_(PDISASM pMyDisasm)
563{
564 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
565 /* ========== 0x66 */
566 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
567 GV.OperandSize = GV.OriginalOperandSize;
568 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
569 GV.MemDecoration = Arg2dqword;
570 #ifndef BEA_LIGHT_DISASSEMBLY
571 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddsb ");
572 #endif
573 GV.SSE_ = 1;
574 GxEx(pMyDisasm);
575 GV.SSE_ = 0;
576 }
577 else {
578 GV.MemDecoration = Arg2qword;
579 #ifndef BEA_LIGHT_DISASSEMBLY
580 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddsb ");
581 #endif
582 GV.MMX_ = 1;
583 GxEx(pMyDisasm);
584 GV.MMX_ = 0;
585 }
586}
587
588/* ====================================================================
589 * 0x 0f ed
590 * ==================================================================== */
591void __bea_callspec__ paddsw_(PDISASM pMyDisasm)
592{
593 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
594 /* ========== 0x66 */
595 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
596 GV.OperandSize = GV.OriginalOperandSize;
597 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
598 GV.MemDecoration = Arg2dqword;
599 #ifndef BEA_LIGHT_DISASSEMBLY
600 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddsw ");
601 #endif
602 GV.SSE_ = 1;
603 GxEx(pMyDisasm);
604 GV.SSE_ = 0;
605 }
606 else {
607 GV.MemDecoration = Arg2qword;
608 #ifndef BEA_LIGHT_DISASSEMBLY
609 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddsw ");
610 #endif
611 GV.MMX_ = 1;
612 GxEx(pMyDisasm);
613 GV.MMX_ = 0;
614 }
615}
616
617/* ====================================================================
618 * 0x 0f dc
619 * ==================================================================== */
620void __bea_callspec__ paddusb_(PDISASM pMyDisasm)
621{
622 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
623 /* ========== 0x66 */
624 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
625 GV.OperandSize = GV.OriginalOperandSize;
626 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
627 GV.MemDecoration = Arg2dqword;
628 #ifndef BEA_LIGHT_DISASSEMBLY
629 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddusb ");
630 #endif
631 GV.SSE_ = 1;
632 GxEx(pMyDisasm);
633 GV.SSE_ = 0;
634 }
635 else {
636 GV.MemDecoration = Arg2qword;
637 #ifndef BEA_LIGHT_DISASSEMBLY
638 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddusb ");
639 #endif
640 GV.MMX_ = 1;
641 GxEx(pMyDisasm);
642 GV.MMX_ = 0;
643 }
644}
645
646/* ====================================================================
647 * 0x 0f dd
648 * ==================================================================== */
649void __bea_callspec__ paddusw_(PDISASM pMyDisasm)
650{
651 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
652 /* ========== 0x66 */
653 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
654 GV.OperandSize = GV.OriginalOperandSize;
655 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
656 GV.MemDecoration = Arg2dqword;
657 #ifndef BEA_LIGHT_DISASSEMBLY
658 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddusw ");
659 #endif
660 GV.SSE_ = 1;
661 GxEx(pMyDisasm);
662 GV.SSE_ = 0;
663 }
664 else {
665 GV.MemDecoration = Arg2qword;
666 #ifndef BEA_LIGHT_DISASSEMBLY
667 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "paddusw ");
668 #endif
669 GV.MMX_ = 1;
670 GxEx(pMyDisasm);
671 GV.MMX_ = 0;
672 }
673}
674
675/* ====================================================================
676 * 0x 0f db
677 * ==================================================================== */
678void __bea_callspec__ pand_(PDISASM pMyDisasm)
679{
680 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+LOGICAL_INSTRUCTION;
681 /* ========== 0x66 */
682 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
683 GV.OperandSize = GV.OriginalOperandSize;
684 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
685 GV.MemDecoration = Arg2dqword;
686 #ifndef BEA_LIGHT_DISASSEMBLY
687 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pand ");
688 #endif
689 GV.SSE_ = 1;
690 GxEx(pMyDisasm);
691 GV.SSE_ = 0;
692 }
693 else {
694 GV.MemDecoration = Arg2qword;
695 #ifndef BEA_LIGHT_DISASSEMBLY
696 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pand ");
697 #endif
698 GV.MMX_ = 1;
699 GxEx(pMyDisasm);
700 GV.MMX_ = 0;
701 }
702}
703/* ====================================================================
704 * 0x 0f df
705 * ==================================================================== */
706void __bea_callspec__ pandn_(PDISASM pMyDisasm)
707{
708 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+LOGICAL_INSTRUCTION;
709 /* ========== 0x66 */
710 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
711 GV.OperandSize = GV.OriginalOperandSize;
712 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
713 GV.MemDecoration = Arg2dqword;
714 #ifndef BEA_LIGHT_DISASSEMBLY
715 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pandn ");
716 #endif
717 GV.SSE_ = 1;
718 GxEx(pMyDisasm);
719 GV.SSE_ = 0;
720 }
721 else {
722 GV.MemDecoration = Arg2qword;
723 #ifndef BEA_LIGHT_DISASSEMBLY
724 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pandn ");
725 #endif
726 GV.MMX_ = 1;
727 GxEx(pMyDisasm);
728 GV.MMX_ = 0;
729 }
730}
731
732/* ====================================================================
733 * 0x 0f 74
734 * ==================================================================== */
735void __bea_callspec__ pcmpeqb_(PDISASM pMyDisasm)
736{
737 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
738 /* ========== 0x66 */
739 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
740 GV.OperandSize = GV.OriginalOperandSize;
741 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
742 GV.MemDecoration = Arg2dqword;
743 #ifndef BEA_LIGHT_DISASSEMBLY
744 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqb ");
745 #endif
746 (*pMyDisasm).Argument1.AccessMode = READ;
747 GV.SSE_ = 1;
748 GxEx(pMyDisasm);
749 GV.SSE_ = 0;
750 }
751 else {
752 GV.MemDecoration = Arg2qword;
753 #ifndef BEA_LIGHT_DISASSEMBLY
754 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqb ");
755 #endif
756 (*pMyDisasm).Argument1.AccessMode = READ;
757 GV.MMX_ = 1;
758 GxEx(pMyDisasm);
759 GV.MMX_ = 0;
760 }
761}
762
763/* ====================================================================
764 * 0x 0f 75
765 * ==================================================================== */
766void __bea_callspec__ pcmpeqw_(PDISASM pMyDisasm)
767{
768 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
769 /* ========== 0x66 */
770 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
771 GV.OperandSize = GV.OriginalOperandSize;
772 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
773 GV.MemDecoration = Arg2dqword;
774 #ifndef BEA_LIGHT_DISASSEMBLY
775 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqw ");
776 #endif
777 (*pMyDisasm).Argument1.AccessMode = READ;
778 GV.SSE_ = 1;
779 GxEx(pMyDisasm);
780 GV.SSE_ = 0;
781 }
782 else {
783 GV.MemDecoration = Arg2qword;
784 #ifndef BEA_LIGHT_DISASSEMBLY
785 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqw ");
786 #endif
787 (*pMyDisasm).Argument1.AccessMode = READ;
788 GV.MMX_ = 1;
789 GxEx(pMyDisasm);
790 GV.MMX_ = 0;
791 }
792}
793
794/* ====================================================================
795 * 0x 0f 76
796 * ==================================================================== */
797void __bea_callspec__ pcmpeqd_(PDISASM pMyDisasm)
798{
799 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
800 /* ========== 0x66 */
801 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
802 GV.OperandSize = GV.OriginalOperandSize;
803 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
804 GV.MemDecoration = Arg2dqword;
805 #ifndef BEA_LIGHT_DISASSEMBLY
806 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqd ");
807 #endif
808 (*pMyDisasm).Argument1.AccessMode = READ;
809 GV.SSE_ = 1;
810 GxEx(pMyDisasm);
811 GV.SSE_ = 0;
812 }
813 else {
814 GV.MemDecoration = Arg2qword;
815 #ifndef BEA_LIGHT_DISASSEMBLY
816 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpeqd ");
817 #endif
818 (*pMyDisasm).Argument1.AccessMode = READ;
819 GV.MMX_ = 1;
820 GxEx(pMyDisasm);
821 GV.MMX_ = 0;
822 }
823}
824
825/* ====================================================================
826 * 0x 0f 64
827 * ==================================================================== */
828void __bea_callspec__ pcmpgtb_(PDISASM pMyDisasm)
829{
830 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
831 /* ========== 0x66 */
832 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
833 GV.OperandSize = GV.OriginalOperandSize;
834 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
835 GV.MemDecoration = Arg2dqword;
836 #ifndef BEA_LIGHT_DISASSEMBLY
837 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtb ");
838 #endif
839 (*pMyDisasm).Argument1.AccessMode = READ;
840 GV.SSE_ = 1;
841 GxEx(pMyDisasm);
842 GV.SSE_ = 0;
843 }
844 else {
845 GV.MemDecoration = Arg2qword;
846 #ifndef BEA_LIGHT_DISASSEMBLY
847 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtb ");
848 #endif
849 (*pMyDisasm).Argument1.AccessMode = READ;
850 GV.MMX_ = 1;
851 GxEx(pMyDisasm);
852 GV.MMX_ = 0;
853 }
854}
855
856/* ====================================================================
857 * 0x 0f 65
858 * ==================================================================== */
859void __bea_callspec__ pcmpgtw_(PDISASM pMyDisasm)
860{
861 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
862 /* ========== 0x66 */
863 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
864 GV.OperandSize = GV.OriginalOperandSize;
865 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
866 GV.MemDecoration = Arg2dqword;
867 #ifndef BEA_LIGHT_DISASSEMBLY
868 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtw ");
869 #endif
870 (*pMyDisasm).Argument1.AccessMode = READ;
871 GV.SSE_ = 1;
872 GxEx(pMyDisasm);
873 GV.SSE_ = 0;
874 }
875 else {
876 GV.MemDecoration = Arg2qword;
877 #ifndef BEA_LIGHT_DISASSEMBLY
878 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtw ");
879 #endif
880 (*pMyDisasm).Argument1.AccessMode = READ;
881 GV.MMX_ = 1;
882 GxEx(pMyDisasm);
883 GV.MMX_ = 0;
884 }
885}
886
887/* ====================================================================
888 * 0x 0f 66
889 * ==================================================================== */
890void __bea_callspec__ pcmpgtd_(PDISASM pMyDisasm)
891{
892 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+COMPARISON_INSTRUCTION;
893 /* ========== 0x66 */
894 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
895 GV.OperandSize = GV.OriginalOperandSize;
896 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
897 GV.MemDecoration = Arg2dqword;
898 #ifndef BEA_LIGHT_DISASSEMBLY
899 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtd ");
900 #endif
901 (*pMyDisasm).Argument1.AccessMode = READ;
902 GV.SSE_ = 1;
903 GxEx(pMyDisasm);
904 GV.SSE_ = 0;
905 }
906 else {
907 GV.MemDecoration = Arg2qword;
908 #ifndef BEA_LIGHT_DISASSEMBLY
909 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pcmpgtd ");
910 #endif
911 (*pMyDisasm).Argument1.AccessMode = READ;
912 GV.MMX_ = 1;
913 GxEx(pMyDisasm);
914 GV.MMX_ = 0;
915 }
916}
917
918/* ====================================================================
919 * 0x 0f e5
920 * ==================================================================== */
921void __bea_callspec__ pmulhw_(PDISASM pMyDisasm)
922{
923 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
924 /* ========== 0x66 */
925 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
926 GV.OperandSize = GV.OriginalOperandSize;
927 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
928 GV.MemDecoration = Arg2dqword;
929 #ifndef BEA_LIGHT_DISASSEMBLY
930 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhw ");
931 #endif
932 (*pMyDisasm).Argument1.AccessMode = READ;
933 GV.SSE_ = 1;
934 GxEx(pMyDisasm);
935 GV.SSE_ = 0;
936 }
937 else {
938 GV.MemDecoration = Arg2qword;
939 #ifndef BEA_LIGHT_DISASSEMBLY
940 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmulhw ");
941 #endif
942 (*pMyDisasm).Argument1.AccessMode = READ;
943 GV.MMX_ = 1;
944 GxEx(pMyDisasm);
945 GV.MMX_ = 0;
946 }
947}
948
949/* ====================================================================
950 * 0x 0f d5
951 * ==================================================================== */
952void __bea_callspec__ pmullw_(PDISASM pMyDisasm)
953{
954 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
955 /* ========== 0x66 */
956 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
957 GV.OperandSize = GV.OriginalOperandSize;
958 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
959 GV.MemDecoration = Arg2dqword;
960 #ifndef BEA_LIGHT_DISASSEMBLY
961 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmullw ");
962 #endif
963 (*pMyDisasm).Argument1.AccessMode = READ;
964 GV.SSE_ = 1;
965 GxEx(pMyDisasm);
966 GV.SSE_ = 0;
967 }
968 else {
969 GV.MemDecoration = Arg2qword;
970 #ifndef BEA_LIGHT_DISASSEMBLY
971 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmullw ");
972 #endif
973 (*pMyDisasm).Argument1.AccessMode = READ;
974 GV.MMX_ = 1;
975 GxEx(pMyDisasm);
976 GV.MMX_ = 0;
977 }
978}
979
980/* ====================================================================
981 * 0x 0f f5
982 * ==================================================================== */
983void __bea_callspec__ pmaddwd_(PDISASM pMyDisasm)
984{
985 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
986 /* ========== 0x66 */
987 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
988 GV.OperandSize = GV.OriginalOperandSize;
989 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
990 GV.MemDecoration = Arg2dqword;
991 #ifndef BEA_LIGHT_DISASSEMBLY
992 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaddwd ");
993 #endif
994 (*pMyDisasm).Argument1.AccessMode = READ;
995 GV.SSE_ = 1;
996 GxEx(pMyDisasm);
997 GV.SSE_ = 0;
998 }
999 else {
1000 GV.MemDecoration = Arg2qword;
1001 #ifndef BEA_LIGHT_DISASSEMBLY
1002 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pmaddwd ");
1003 #endif
1004 (*pMyDisasm).Argument1.AccessMode = READ;
1005 GV.MMX_ = 1;
1006 GxEx(pMyDisasm);
1007 GV.MMX_ = 0;
1008 }
1009}
1010
1011/* ====================================================================
1012 * 0x 0f eb
1013 * ==================================================================== */
1014void __bea_callspec__ por_(PDISASM pMyDisasm)
1015{
1016 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+LOGICAL_INSTRUCTION;
1017 /* ========== 0x66 */
1018 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1019 GV.OperandSize = GV.OriginalOperandSize;
1020 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1021 GV.MemDecoration = Arg2dqword;
1022 #ifndef BEA_LIGHT_DISASSEMBLY
1023 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "por ");
1024 #endif
1025 (*pMyDisasm).Argument1.AccessMode = READ;
1026 GV.SSE_ = 1;
1027 GxEx(pMyDisasm);
1028 GV.SSE_ = 0;
1029 }
1030 else {
1031 GV.MemDecoration = Arg2qword;
1032 #ifndef BEA_LIGHT_DISASSEMBLY
1033 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "por ");
1034 #endif
1035 (*pMyDisasm).Argument1.AccessMode = READ;
1036 GV.MMX_ = 1;
1037 GxEx(pMyDisasm);
1038 GV.MMX_ = 0;
1039 }
1040}
1041
1042/* ====================================================================
1043 * 0x 0f f1
1044 * ==================================================================== */
1045void __bea_callspec__ psllw_(PDISASM pMyDisasm)
1046{
1047 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1048 /* ========== 0x66 */
1049 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1050 GV.OperandSize = GV.OriginalOperandSize;
1051 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1052 GV.MemDecoration = Arg2dqword;
1053 #ifndef BEA_LIGHT_DISASSEMBLY
1054 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psllw ");
1055 #endif
1056 (*pMyDisasm).Argument1.AccessMode = READ;
1057 GV.SSE_ = 1;
1058 GxEx(pMyDisasm);
1059 GV.SSE_ = 0;
1060 }
1061 else {
1062 GV.MemDecoration = Arg2qword;
1063 #ifndef BEA_LIGHT_DISASSEMBLY
1064 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psllw ");
1065 #endif
1066 (*pMyDisasm).Argument1.AccessMode = READ;
1067 GV.MMX_ = 1;
1068 GxEx(pMyDisasm);
1069 GV.MMX_ = 0;
1070 }
1071}
1072
1073/* ====================================================================
1074 * 0x 0f f2
1075 * ==================================================================== */
1076void __bea_callspec__ pslld_(PDISASM pMyDisasm)
1077{
1078 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1079 /* ========== 0x66 */
1080 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1081 GV.OperandSize = GV.OriginalOperandSize;
1082 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1083 GV.MemDecoration = Arg2dqword;
1084 #ifndef BEA_LIGHT_DISASSEMBLY
1085 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pslld ");
1086 #endif
1087 (*pMyDisasm).Argument1.AccessMode = READ;
1088 GV.SSE_ = 1;
1089 GxEx(pMyDisasm);
1090 GV.SSE_ = 0;
1091 }
1092 else {
1093 GV.MemDecoration = Arg2qword;
1094 #ifndef BEA_LIGHT_DISASSEMBLY
1095 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pslld ");
1096 #endif
1097 (*pMyDisasm).Argument1.AccessMode = READ;
1098 GV.MMX_ = 1;
1099 GxEx(pMyDisasm);
1100 GV.MMX_ = 0;
1101 }
1102}
1103
1104/* ====================================================================
1105 * 0x 0f f3
1106 * ==================================================================== */
1107void __bea_callspec__ psllq_(PDISASM pMyDisasm)
1108{
1109 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1110 /* ========== 0x66 */
1111 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1112 GV.OperandSize = GV.OriginalOperandSize;
1113 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1114 GV.MemDecoration = Arg2dqword;
1115 #ifndef BEA_LIGHT_DISASSEMBLY
1116 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psllq ");
1117 #endif
1118 (*pMyDisasm).Argument1.AccessMode = READ;
1119 GV.SSE_ = 1;
1120 GxEx(pMyDisasm);
1121 GV.SSE_ = 0;
1122 }
1123 else {
1124 GV.MemDecoration = Arg2qword;
1125 #ifndef BEA_LIGHT_DISASSEMBLY
1126 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psllq ");
1127 #endif
1128 (*pMyDisasm).Argument1.AccessMode = READ;
1129 GV.MMX_ = 1;
1130 GxEx(pMyDisasm);
1131 GV.MMX_ = 0;
1132 }
1133}
1134
1135/* ====================================================================
1136 * 0x 0f d1
1137 * ==================================================================== */
1138void __bea_callspec__ psrlw_(PDISASM pMyDisasm)
1139{
1140 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1141 /* ========== 0x66 */
1142 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1143 GV.OperandSize = GV.OriginalOperandSize;
1144 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1145 GV.MemDecoration = Arg2dqword;
1146 #ifndef BEA_LIGHT_DISASSEMBLY
1147 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrlw ");
1148 #endif
1149 (*pMyDisasm).Argument1.AccessMode = READ;
1150 GV.SSE_ = 1;
1151 GxEx(pMyDisasm);
1152 GV.SSE_ = 0;
1153 }
1154 else {
1155 GV.MemDecoration = Arg2qword;
1156 #ifndef BEA_LIGHT_DISASSEMBLY
1157 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrlw ");
1158 #endif
1159 (*pMyDisasm).Argument1.AccessMode = READ;
1160 GV.MMX_ = 1;
1161 GxEx(pMyDisasm);
1162 GV.MMX_ = 0;
1163 }
1164}
1165
1166/* ====================================================================
1167 * 0x 0f d2
1168 * ==================================================================== */
1169void __bea_callspec__ psrld_(PDISASM pMyDisasm)
1170{
1171 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1172 /* ========== 0x66 */
1173 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1174 GV.OperandSize = GV.OriginalOperandSize;
1175 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1176 GV.MemDecoration = Arg2dqword;
1177 #ifndef BEA_LIGHT_DISASSEMBLY
1178 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrld ");
1179 #endif
1180 (*pMyDisasm).Argument1.AccessMode = READ;
1181 GV.SSE_ = 1;
1182 GxEx(pMyDisasm);
1183 GV.SSE_ = 0;
1184 }
1185 else {
1186 GV.MemDecoration = Arg2qword;
1187 #ifndef BEA_LIGHT_DISASSEMBLY
1188 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrld ");
1189 #endif
1190 (*pMyDisasm).Argument1.AccessMode = READ;
1191 GV.MMX_ = 1;
1192 GxEx(pMyDisasm);
1193 GV.MMX_ = 0;
1194 }
1195}
1196
1197/* ====================================================================
1198 * 0x 0f d3
1199 * ==================================================================== */
1200void __bea_callspec__ psrlq_(PDISASM pMyDisasm)
1201{
1202 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1203 /* ========== 0x66 */
1204 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1205 GV.OperandSize = GV.OriginalOperandSize;
1206 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1207 GV.MemDecoration = Arg2dqword;
1208 #ifndef BEA_LIGHT_DISASSEMBLY
1209 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrlq ");
1210 #endif
1211 (*pMyDisasm).Argument1.AccessMode = READ;
1212 GV.SSE_ = 1;
1213 GxEx(pMyDisasm);
1214 GV.SSE_ = 0;
1215 }
1216 else {
1217 GV.MemDecoration = Arg2qword;
1218 #ifndef BEA_LIGHT_DISASSEMBLY
1219 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrlq ");
1220 #endif
1221 (*pMyDisasm).Argument1.AccessMode = READ;
1222 GV.MMX_ = 1;
1223 GxEx(pMyDisasm);
1224 GV.MMX_ = 0;
1225 }
1226}
1227
1228/* ====================================================================
1229 * 0x 0f e1
1230 * ==================================================================== */
1231void __bea_callspec__ psraw_(PDISASM pMyDisasm)
1232{
1233 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1234 /* ========== 0x66 */
1235 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1236 GV.OperandSize = GV.OriginalOperandSize;
1237 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1238 GV.MemDecoration = Arg2dqword;
1239 #ifndef BEA_LIGHT_DISASSEMBLY
1240 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psraw ");
1241 #endif
1242 (*pMyDisasm).Argument1.AccessMode = READ;
1243 GV.SSE_ = 1;
1244 GxEx(pMyDisasm);
1245 GV.SSE_ = 0;
1246 }
1247 else {
1248 GV.MemDecoration = Arg2qword;
1249 #ifndef BEA_LIGHT_DISASSEMBLY
1250 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psraw ");
1251 #endif
1252 (*pMyDisasm).Argument1.AccessMode = READ;
1253 GV.MMX_ = 1;
1254 GxEx(pMyDisasm);
1255 GV.MMX_ = 0;
1256 }
1257}
1258
1259/* ====================================================================
1260 * 0x 0f e2
1261 * ==================================================================== */
1262void __bea_callspec__ psrad_(PDISASM pMyDisasm)
1263{
1264 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+SHIFT_ROTATE;
1265 /* ========== 0x66 */
1266 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1267 GV.OperandSize = GV.OriginalOperandSize;
1268 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1269 GV.MemDecoration = Arg2dqword;
1270 #ifndef BEA_LIGHT_DISASSEMBLY
1271 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrad ");
1272 #endif
1273 (*pMyDisasm).Argument1.AccessMode = READ;
1274 GV.SSE_ = 1;
1275 GxEx(pMyDisasm);
1276 GV.SSE_ = 0;
1277 }
1278 else {
1279 GV.MemDecoration = Arg2qword;
1280 #ifndef BEA_LIGHT_DISASSEMBLY
1281 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psrad ");
1282 #endif
1283 (*pMyDisasm).Argument1.AccessMode = READ;
1284 GV.MMX_ = 1;
1285 GxEx(pMyDisasm);
1286 GV.MMX_ = 0;
1287 }
1288}
1289
1290/* ====================================================================
1291 * 0x 0f f8
1292 * ==================================================================== */
1293void __bea_callspec__ psubb_(PDISASM pMyDisasm)
1294{
1295 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1296 /* ========== 0x66 */
1297 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1298 GV.OperandSize = GV.OriginalOperandSize;
1299 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1300 GV.MemDecoration = Arg2dqword;
1301 #ifndef BEA_LIGHT_DISASSEMBLY
1302 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubb ");
1303 #endif
1304 (*pMyDisasm).Argument1.AccessMode = READ;
1305 GV.SSE_ = 1;
1306 GxEx(pMyDisasm);
1307 GV.SSE_ = 0;
1308 }
1309 else {
1310 GV.MemDecoration = Arg2qword;
1311 #ifndef BEA_LIGHT_DISASSEMBLY
1312 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubb ");
1313 #endif
1314 (*pMyDisasm).Argument1.AccessMode = READ;
1315 GV.MMX_ = 1;
1316 GxEx(pMyDisasm);
1317 GV.MMX_ = 0;
1318 }
1319}
1320
1321/* ====================================================================
1322 * 0x 0f f9
1323 * ==================================================================== */
1324void __bea_callspec__ psubw_(PDISASM pMyDisasm)
1325{
1326 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1327 /* ========== 0x66 */
1328 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1329 GV.OperandSize = GV.OriginalOperandSize;
1330 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1331 GV.MemDecoration = Arg2dqword;
1332 #ifndef BEA_LIGHT_DISASSEMBLY
1333 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubw ");
1334 #endif
1335 (*pMyDisasm).Argument1.AccessMode = READ;
1336 GV.SSE_ = 1;
1337 GxEx(pMyDisasm);
1338 GV.SSE_ = 0;
1339 }
1340 else {
1341 GV.MemDecoration = Arg2qword;
1342 #ifndef BEA_LIGHT_DISASSEMBLY
1343 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubw ");
1344 #endif
1345 (*pMyDisasm).Argument1.AccessMode = READ;
1346 GV.MMX_ = 1;
1347 GxEx(pMyDisasm);
1348 GV.MMX_ = 0;
1349 }
1350}
1351
1352/* ====================================================================
1353 * 0x 0f fa
1354 * ==================================================================== */
1355void __bea_callspec__ psubd_(PDISASM pMyDisasm)
1356{
1357 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1358 /* ========== 0x66 */
1359 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1360 GV.OperandSize = GV.OriginalOperandSize;
1361 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1362 GV.MemDecoration = Arg2dqword;
1363 #ifndef BEA_LIGHT_DISASSEMBLY
1364 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubd ");
1365 #endif
1366 (*pMyDisasm).Argument1.AccessMode = READ;
1367 GV.SSE_ = 1;
1368 GxEx(pMyDisasm);
1369 GV.SSE_ = 0;
1370 }
1371 else {
1372 GV.MemDecoration = Arg2qword;
1373 #ifndef BEA_LIGHT_DISASSEMBLY
1374 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubd ");
1375 #endif
1376 (*pMyDisasm).Argument1.AccessMode = READ;
1377 GV.MMX_ = 1;
1378 GxEx(pMyDisasm);
1379 GV.MMX_ = 0;
1380 }
1381}
1382
1383/* ====================================================================
1384 * 0x 0f e8
1385 * ==================================================================== */
1386void __bea_callspec__ psubsb_(PDISASM pMyDisasm)
1387{
1388 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1389 /* ========== 0x66 */
1390 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1391 GV.OperandSize = GV.OriginalOperandSize;
1392 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1393 GV.MemDecoration = Arg2dqword;
1394 #ifndef BEA_LIGHT_DISASSEMBLY
1395 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubsb ");
1396 #endif
1397 (*pMyDisasm).Argument1.AccessMode = READ;
1398 GV.SSE_ = 1;
1399 GxEx(pMyDisasm);
1400 GV.SSE_ = 0;
1401 }
1402 else {
1403 GV.MemDecoration = Arg2qword;
1404 #ifndef BEA_LIGHT_DISASSEMBLY
1405 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubsb ");
1406 #endif
1407 (*pMyDisasm).Argument1.AccessMode = READ;
1408 GV.MMX_ = 1;
1409 GxEx(pMyDisasm);
1410 GV.MMX_ = 0;
1411 }
1412}
1413
1414/* ====================================================================
1415 * 0x 0f e9
1416 * ==================================================================== */
1417void __bea_callspec__ psubsw_(PDISASM pMyDisasm)
1418{
1419 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1420 /* ========== 0x66 */
1421 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1422 GV.OperandSize = GV.OriginalOperandSize;
1423 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1424 GV.MemDecoration = Arg2dqword;
1425 #ifndef BEA_LIGHT_DISASSEMBLY
1426 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubsw ");
1427 #endif
1428 (*pMyDisasm).Argument1.AccessMode = READ;
1429 GV.SSE_ = 1;
1430 GxEx(pMyDisasm);
1431 GV.SSE_ = 0;
1432 }
1433 else {
1434 GV.MemDecoration = Arg2qword;
1435 #ifndef BEA_LIGHT_DISASSEMBLY
1436 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubsw ");
1437 #endif
1438 (*pMyDisasm).Argument1.AccessMode = READ;
1439 GV.MMX_ = 1;
1440 GxEx(pMyDisasm);
1441 GV.MMX_ = 0;
1442 }
1443}
1444
1445/* ====================================================================
1446 * 0x 0f d8
1447 * ==================================================================== */
1448void __bea_callspec__ psubusb_(PDISASM pMyDisasm)
1449{
1450 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1451 /* ========== 0x66 */
1452 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1453 GV.OperandSize = GV.OriginalOperandSize;
1454 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1455 GV.MemDecoration = Arg2dqword;
1456 #ifndef BEA_LIGHT_DISASSEMBLY
1457 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubusb ");
1458 #endif
1459 (*pMyDisasm).Argument1.AccessMode = READ;
1460 GV.SSE_ = 1;
1461 GxEx(pMyDisasm);
1462 GV.SSE_ = 0;
1463 }
1464 else {
1465 GV.MemDecoration = Arg2qword;
1466 #ifndef BEA_LIGHT_DISASSEMBLY
1467 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubusb ");
1468 #endif
1469 (*pMyDisasm).Argument1.AccessMode = READ;
1470 GV.MMX_ = 1;
1471 GxEx(pMyDisasm);
1472 GV.MMX_ = 0;
1473 }
1474}
1475
1476/* ====================================================================
1477 * 0x 0f d9
1478 * ==================================================================== */
1479void __bea_callspec__ psubusw_(PDISASM pMyDisasm)
1480{
1481 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+ARITHMETIC_INSTRUCTION;
1482 /* ========== 0x66 */
1483 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1484 GV.OperandSize = GV.OriginalOperandSize;
1485 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1486 GV.MemDecoration = Arg2dqword;
1487 #ifndef BEA_LIGHT_DISASSEMBLY
1488 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubusw ");
1489 #endif
1490 (*pMyDisasm).Argument1.AccessMode = READ;
1491 GV.SSE_ = 1;
1492 GxEx(pMyDisasm);
1493 GV.SSE_ = 0;
1494 }
1495 else {
1496 GV.MemDecoration = Arg2qword;
1497 #ifndef BEA_LIGHT_DISASSEMBLY
1498 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "psubusw ");
1499 #endif
1500 (*pMyDisasm).Argument1.AccessMode = READ;
1501 GV.MMX_ = 1;
1502 GxEx(pMyDisasm);
1503 GV.MMX_ = 0;
1504 }
1505}
1506
1507/* ====================================================================
1508 * 0x 0f 68
1509 * ==================================================================== */
1510void __bea_callspec__ punpckhbw_(PDISASM pMyDisasm)
1511{
1512 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1513 /* ========== 0x66 */
1514 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1515 GV.OperandSize = GV.OriginalOperandSize;
1516 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1517 GV.MemDecoration = Arg2dqword;
1518 #ifndef BEA_LIGHT_DISASSEMBLY
1519 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhbw ");
1520 #endif
1521 (*pMyDisasm).Argument1.AccessMode = READ;
1522 GV.SSE_ = 1;
1523 GxEx(pMyDisasm);
1524 GV.SSE_ = 0;
1525 }
1526 else {
1527 GV.MemDecoration = Arg2qword;
1528 #ifndef BEA_LIGHT_DISASSEMBLY
1529 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhbw ");
1530 #endif
1531 (*pMyDisasm).Argument1.AccessMode = READ;
1532 GV.MMX_ = 1;
1533 GxEx(pMyDisasm);
1534 GV.MMX_ = 0;
1535 }
1536}
1537
1538/* ====================================================================
1539 * 0x 0f 69
1540 * ==================================================================== */
1541void __bea_callspec__ punpckhwd_(PDISASM pMyDisasm)
1542{
1543 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1544 /* ========== 0x66 */
1545 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1546 GV.OperandSize = GV.OriginalOperandSize;
1547 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1548 GV.MemDecoration = Arg2dqword;
1549 #ifndef BEA_LIGHT_DISASSEMBLY
1550 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhwd ");
1551 #endif
1552 (*pMyDisasm).Argument1.AccessMode = READ;
1553 GV.SSE_ = 1;
1554 GxEx(pMyDisasm);
1555 GV.SSE_ = 0;
1556 }
1557 else {
1558 GV.MemDecoration = Arg2qword;
1559 #ifndef BEA_LIGHT_DISASSEMBLY
1560 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhwd ");
1561 #endif
1562 (*pMyDisasm).Argument1.AccessMode = READ;
1563 GV.MMX_ = 1;
1564 GxEx(pMyDisasm);
1565 GV.MMX_ = 0;
1566 }
1567}
1568
1569/* ====================================================================
1570 * 0x 0f 6a
1571 * ==================================================================== */
1572void __bea_callspec__ punpckhdq_(PDISASM pMyDisasm)
1573{
1574 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1575 /* ========== 0x66 */
1576 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1577 GV.OperandSize = GV.OriginalOperandSize;
1578 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1579 GV.MemDecoration = Arg2dqword;
1580 #ifndef BEA_LIGHT_DISASSEMBLY
1581 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhdq ");
1582 #endif
1583 (*pMyDisasm).Argument1.AccessMode = READ;
1584 GV.SSE_ = 1;
1585 GxEx(pMyDisasm);
1586 GV.SSE_ = 0;
1587 }
1588 else {
1589 GV.MemDecoration = Arg2qword;
1590 #ifndef BEA_LIGHT_DISASSEMBLY
1591 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckhdq ");
1592 #endif
1593 (*pMyDisasm).Argument1.AccessMode = READ;
1594 GV.MMX_ = 1;
1595 GxEx(pMyDisasm);
1596 GV.MMX_ = 0;
1597 }
1598}
1599
1600/* ====================================================================
1601 * 0x 0f 60
1602 * ==================================================================== */
1603void __bea_callspec__ punpcklbw_(PDISASM pMyDisasm)
1604{
1605 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1606 /* ========== 0x66 */
1607 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1608 GV.OperandSize = GV.OriginalOperandSize;
1609 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1610 GV.MemDecoration = Arg2dqword;
1611 #ifndef BEA_LIGHT_DISASSEMBLY
1612 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklbw ");
1613 #endif
1614 (*pMyDisasm).Argument1.AccessMode = READ;
1615 GV.SSE_ = 1;
1616 GxEx(pMyDisasm);
1617 GV.SSE_ = 0;
1618 }
1619 else {
1620 GV.MemDecoration = Arg2qword;
1621 #ifndef BEA_LIGHT_DISASSEMBLY
1622 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklbw ");
1623 #endif
1624 (*pMyDisasm).Argument1.AccessMode = READ;
1625 GV.MMX_ = 1;
1626 GxEx(pMyDisasm);
1627 GV.MMX_ = 0;
1628 }
1629}
1630
1631/* ====================================================================
1632 * 0x 0f 61
1633 * ==================================================================== */
1634void __bea_callspec__ punpcklwd_(PDISASM pMyDisasm)
1635{
1636 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1637 /* ========== 0x66 */
1638 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1639 GV.OperandSize = GV.OriginalOperandSize;
1640 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1641 GV.MemDecoration = Arg2dqword;
1642 #ifndef BEA_LIGHT_DISASSEMBLY
1643 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklwd ");
1644 #endif
1645 (*pMyDisasm).Argument1.AccessMode = READ;
1646 GV.SSE_ = 1;
1647 GxEx(pMyDisasm);
1648 GV.SSE_ = 0;
1649 }
1650 else {
1651 GV.MemDecoration = Arg2qword;
1652 #ifndef BEA_LIGHT_DISASSEMBLY
1653 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpcklwd ");
1654 #endif
1655 (*pMyDisasm).Argument1.AccessMode = READ;
1656 GV.MMX_ = 1;
1657 GxEx(pMyDisasm);
1658 GV.MMX_ = 0;
1659 }
1660}
1661
1662/* ====================================================================
1663 * 0x 0f 62
1664 * ==================================================================== */
1665void __bea_callspec__ punpckldq_(PDISASM pMyDisasm)
1666{
1667 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+CONVERSION_INSTRUCTION;
1668 /* ========== 0x66 */
1669 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1670 GV.OperandSize = GV.OriginalOperandSize;
1671 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1672 GV.MemDecoration = Arg2dqword;
1673 #ifndef BEA_LIGHT_DISASSEMBLY
1674 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckldq ");
1675 #endif
1676 (*pMyDisasm).Argument1.AccessMode = READ;
1677 GV.SSE_ = 1;
1678 GxEx(pMyDisasm);
1679 GV.SSE_ = 0;
1680 }
1681 else {
1682 GV.MemDecoration = Arg2qword;
1683 #ifndef BEA_LIGHT_DISASSEMBLY
1684 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "punpckldq ");
1685 #endif
1686 (*pMyDisasm).Argument1.AccessMode = READ;
1687 GV.MMX_ = 1;
1688 GxEx(pMyDisasm);
1689 GV.MMX_ = 0;
1690 }
1691}
1692
1693/* ====================================================================
1694 * 0x 0f ef
1695 * ==================================================================== */
1696void __bea_callspec__ pxor_(PDISASM pMyDisasm)
1697{
1698 (*pMyDisasm).Instruction.Category = MMX_INSTRUCTION+LOGICAL_INSTRUCTION;
1699 /* ========== 0x66 */
1700 if ((*pMyDisasm).Prefix.OperandSize == InUsePrefix) {
1701 GV.OperandSize = GV.OriginalOperandSize;
1702 (*pMyDisasm).Prefix.OperandSize = MandatoryPrefix;
1703 GV.MemDecoration = Arg2dqword;
1704 #ifndef BEA_LIGHT_DISASSEMBLY
1705 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pxor ");
1706 #endif
1707 (*pMyDisasm).Argument1.AccessMode = READ;
1708 GV.SSE_ = 1;
1709 GxEx(pMyDisasm);
1710 GV.SSE_ = 0;
1711 }
1712 else {
1713 GV.MemDecoration = Arg2qword;
1714 #ifndef BEA_LIGHT_DISASSEMBLY
1715 (void) strcpy ((*pMyDisasm).Instruction.Mnemonic, "pxor ");
1716 #endif
1717 (*pMyDisasm).Argument1.AccessMode = READ;
1718 GV.MMX_ = 1;
1719 GxEx(pMyDisasm);
1720 GV.MMX_ = 0;
1721 }
1722}
Note: See TracBrowser for help on using the repository browser.