VirtualBox

source: vbox/trunk/src/VBox/VMM/VMMAll/IEMAllInstructionsVexMap1.cpp.h@ 72262

Last change on this file since 72262 was 69221, checked in by vboxsync, 7 years ago

VMM: scm cleanups
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 152.0 KB
Line 
1/* $Id: IEMAllInstructionsVexMap1.cpp.h 69221 2017-10-24 15:07:46Z vboxsync $ */
2/** @file
3 * IEM - Instruction Decoding and Emulation.
4 *
5 * @remarks IEMAllInstructionsTwoByte0f.cpp.h is a legacy mirror of this file.
6 * Any update here is likely needed in that file too.
7 */
8
9/*
10 * Copyright (C) 2011-2017 Oracle Corporation
11 *
12 * This file is part of VirtualBox Open Source Edition (OSE), as
13 * available from http://www.virtualbox.org. This file is free software;
14 * you can redistribute it and/or modify it under the terms of the GNU
15 * General Public License (GPL) as published by the Free Software
16 * Foundation, in version 2 as it comes in the "COPYING" file of the
17 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19 */
20
21
22/** @name VEX Opcode Map 1
23 * @{
24 */
25
26
27/* Opcode VEX.0F 0x00 - invalid */
28/* Opcode VEX.0F 0x01 - invalid */
29/* Opcode VEX.0F 0x02 - invalid */
30/* Opcode VEX.0F 0x03 - invalid */
31/* Opcode VEX.0F 0x04 - invalid */
32/* Opcode VEX.0F 0x05 - invalid */
33/* Opcode VEX.0F 0x06 - invalid */
34/* Opcode VEX.0F 0x07 - invalid */
35/* Opcode VEX.0F 0x08 - invalid */
36/* Opcode VEX.0F 0x09 - invalid */
37/* Opcode VEX.0F 0x0a - invalid */
38
39/** Opcode VEX.0F 0x0b. */
40FNIEMOP_DEF(iemOp_vud2)
41{
42 IEMOP_MNEMONIC(vud2, "vud2");
43 return IEMOP_RAISE_INVALID_OPCODE();
44}
45
46/* Opcode VEX.0F 0x0c - invalid */
47/* Opcode VEX.0F 0x0d - invalid */
48/* Opcode VEX.0F 0x0e - invalid */
49/* Opcode VEX.0F 0x0f - invalid */
50
51
52/**
53 * @opcode 0x10
54 * @oppfx none
55 * @opcpuid avx
56 * @opgroup og_avx_simdfp_datamove
57 * @opxcpttype 4UA
58 * @optest op1=1 op2=2 -> op1=2
59 * @optest op1=0 op2=-22 -> op1=-22
60 */
61FNIEMOP_DEF(iemOp_vmovups_Vps_Wps)
62{
63 IEMOP_MNEMONIC2(VEX_RM, VMOVUPS, vmovups, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
64 Assert(pVCpu->iem.s.uVexLength <= 1);
65 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
66 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
67 {
68 /*
69 * Register, register.
70 */
71 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
72 IEM_MC_BEGIN(0, 0);
73 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
74 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
75 if (pVCpu->iem.s.uVexLength == 0)
76 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
77 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
78 else
79 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
80 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
81 IEM_MC_ADVANCE_RIP();
82 IEM_MC_END();
83 }
84 else if (pVCpu->iem.s.uVexLength == 0)
85 {
86 /*
87 * 128-bit: Register, Memory
88 */
89 IEM_MC_BEGIN(0, 2);
90 IEM_MC_LOCAL(RTUINT128U, uSrc);
91 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
92
93 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
94 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
95 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
96 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
97
98 IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
99 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
100
101 IEM_MC_ADVANCE_RIP();
102 IEM_MC_END();
103 }
104 else
105 {
106 /*
107 * 256-bit: Register, Memory
108 */
109 IEM_MC_BEGIN(0, 2);
110 IEM_MC_LOCAL(RTUINT256U, uSrc);
111 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
112
113 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
114 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
115 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
116 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
117
118 IEM_MC_FETCH_MEM_U256(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
119 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
120
121 IEM_MC_ADVANCE_RIP();
122 IEM_MC_END();
123 }
124 return VINF_SUCCESS;
125}
126
127
128/**
129 * @opcode 0x10
130 * @oppfx 0x66
131 * @opcpuid avx
132 * @opgroup og_avx_simdfp_datamove
133 * @opxcpttype 4UA
134 * @optest op1=1 op2=2 -> op1=2
135 * @optest op1=0 op2=-22 -> op1=-22
136 */
137FNIEMOP_DEF(iemOp_vmovupd_Vpd_Wpd)
138{
139 IEMOP_MNEMONIC2(VEX_RM, VMOVUPD, vmovupd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
140 Assert(pVCpu->iem.s.uVexLength <= 1);
141 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
142 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
143 {
144 /*
145 * Register, register.
146 */
147 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
148 IEM_MC_BEGIN(0, 0);
149 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
150 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
151 if (pVCpu->iem.s.uVexLength == 0)
152 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
153 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
154 else
155 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
156 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
157 IEM_MC_ADVANCE_RIP();
158 IEM_MC_END();
159 }
160 else if (pVCpu->iem.s.uVexLength == 0)
161 {
162 /*
163 * 128-bit: Memory, register.
164 */
165 IEM_MC_BEGIN(0, 2);
166 IEM_MC_LOCAL(RTUINT128U, uSrc);
167 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
168
169 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
170 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
171 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
172 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
173
174 IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
175 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
176
177 IEM_MC_ADVANCE_RIP();
178 IEM_MC_END();
179 }
180 else
181 {
182 /*
183 * 256-bit: Memory, register.
184 */
185 IEM_MC_BEGIN(0, 2);
186 IEM_MC_LOCAL(RTUINT256U, uSrc);
187 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
188
189 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
190 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
191 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
192 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
193
194 IEM_MC_FETCH_MEM_U256(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
195 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
196
197 IEM_MC_ADVANCE_RIP();
198 IEM_MC_END();
199 }
200 return VINF_SUCCESS;
201}
202
203
204FNIEMOP_DEF(iemOp_vmovss_Vss_Hss_Wss)
205{
206 Assert(pVCpu->iem.s.uVexLength <= 1);
207 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
208 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
209 {
210 /**
211 * @opcode 0x10
212 * @oppfx 0xf3
213 * @opcodesub 11 mr/reg
214 * @opcpuid avx
215 * @opgroup og_avx_simdfp_datamerge
216 * @opxcpttype 5
217 * @optest op1=1 op2=0 op3=2 -> op1=2
218 * @optest op1=0 op2=0 op3=-22 -> op1=0xffffffea
219 * @optest op1=3 op2=-1 op3=0x77 -> op1=-4294967177
220 * @optest op1=3 op2=-2 op3=0x77 -> op1=-8589934473
221 * @note HssHi refers to bits 127:32.
222 */
223 IEMOP_MNEMONIC3(VEX_RVM_REG, VMOVSS, vmovss, Vss_WO, HssHi, Uss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
224 IEMOP_HLP_DONE_VEX_DECODING();
225 IEM_MC_BEGIN(0, 0);
226
227 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
228 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
229 IEM_MC_MERGE_YREG_U32_U96_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
230 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB /*U32*/,
231 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hss*/);
232 IEM_MC_ADVANCE_RIP();
233 IEM_MC_END();
234 }
235 else
236 {
237 /**
238 * @opdone
239 * @opcode 0x10
240 * @oppfx 0xf3
241 * @opcodesub !11 mr/reg
242 * @opcpuid avx
243 * @opgroup og_avx_simdfp_datamove
244 * @opxcpttype 5
245 * @opfunction iemOp_vmovss_Vss_Hss_Wss
246 * @optest op1=1 op2=2 -> op1=2
247 * @optest op1=0 op2=-22 -> op1=-22
248 */
249 IEMOP_MNEMONIC2(VEX_RM_MEM, VMOVSS, vmovss, VssZx_WO, Md, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
250 IEM_MC_BEGIN(0, 2);
251 IEM_MC_LOCAL(uint32_t, uSrc);
252 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
253
254 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
255 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
256 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
257 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
258
259 IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
260 IEM_MC_STORE_YREG_U32_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
261
262 IEM_MC_ADVANCE_RIP();
263 IEM_MC_END();
264 }
265
266 return VINF_SUCCESS;
267}
268
269
270FNIEMOP_DEF(iemOp_vmovsd_Vsd_Hsd_Wsd)
271{
272 Assert(pVCpu->iem.s.uVexLength <= 1);
273 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
274 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
275 {
276 /**
277 * @opcode 0x10
278 * @oppfx 0xf2
279 * @opcodesub 11 mr/reg
280 * @opcpuid avx
281 * @opgroup og_avx_simdfp_datamerge
282 * @opxcpttype 5
283 * @optest op1=1 op2=0 op3=2 -> op1=2
284 * @optest op1=0 op2=0 op3=-22 -> op1=0xffffffffffffffea
285 * @optest op1=3 op2=-1 op3=0x77 ->
286 * op1=0xffffffffffffffff0000000000000077
287 * @optest op1=3 op2=0x42 op3=0x77 -> op1=0x420000000000000077
288 */
289 IEMOP_MNEMONIC3(VEX_RVM_REG, VMOVSD, vmovsd, Vsd_WO, HsdHi, Usd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
290 IEMOP_HLP_DONE_VEX_DECODING();
291 IEM_MC_BEGIN(0, 0);
292
293 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
294 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
295 IEM_MC_MERGE_YREG_U64_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
296 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB /*U32*/,
297 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hss*/);
298 IEM_MC_ADVANCE_RIP();
299 IEM_MC_END();
300 }
301 else
302 {
303 /**
304 * @opdone
305 * @opcode 0x10
306 * @oppfx 0xf2
307 * @opcodesub !11 mr/reg
308 * @opcpuid avx
309 * @opgroup og_avx_simdfp_datamove
310 * @opxcpttype 5
311 * @opfunction iemOp_vmovsd_Vsd_Hsd_Wsd
312 * @optest op1=1 op2=2 -> op1=2
313 * @optest op1=0 op2=-22 -> op1=-22
314 */
315 IEMOP_MNEMONIC2(VEX_RM_MEM, VMOVSD, vmovsd, VsdZx_WO, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
316 IEM_MC_BEGIN(0, 2);
317 IEM_MC_LOCAL(uint64_t, uSrc);
318 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
319
320 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
321 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
322 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
323 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
324
325 IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
326 IEM_MC_STORE_YREG_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
327
328 IEM_MC_ADVANCE_RIP();
329 IEM_MC_END();
330 }
331
332 return VINF_SUCCESS;
333}
334
335
336/**
337 * @opcode 0x11
338 * @oppfx none
339 * @opcpuid avx
340 * @opgroup og_avx_simdfp_datamove
341 * @opxcpttype 4UA
342 * @optest op1=1 op2=2 -> op1=2
343 * @optest op1=0 op2=-22 -> op1=-22
344 */
345FNIEMOP_DEF(iemOp_vmovups_Wps_Vps)
346{
347 IEMOP_MNEMONIC2(VEX_MR, VMOVUPS, vmovups, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
348 Assert(pVCpu->iem.s.uVexLength <= 1);
349 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
350 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
351 {
352 /*
353 * Register, register.
354 */
355 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
356 IEM_MC_BEGIN(0, 0);
357 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
358 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
359 if (pVCpu->iem.s.uVexLength == 0)
360 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
361 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
362 else
363 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
364 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
365 IEM_MC_ADVANCE_RIP();
366 IEM_MC_END();
367 }
368 else if (pVCpu->iem.s.uVexLength == 0)
369 {
370 /*
371 * 128-bit: Memory, register.
372 */
373 IEM_MC_BEGIN(0, 2);
374 IEM_MC_LOCAL(RTUINT128U, uSrc);
375 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
376
377 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
378 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
379 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
380 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
381
382 IEM_MC_FETCH_YREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
383 IEM_MC_STORE_MEM_U128(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
384
385 IEM_MC_ADVANCE_RIP();
386 IEM_MC_END();
387 }
388 else
389 {
390 /*
391 * 256-bit: Memory, register.
392 */
393 IEM_MC_BEGIN(0, 2);
394 IEM_MC_LOCAL(RTUINT256U, uSrc);
395 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
396
397 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
398 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
399 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
400 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
401
402 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
403 IEM_MC_STORE_MEM_U256(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
404
405 IEM_MC_ADVANCE_RIP();
406 IEM_MC_END();
407 }
408 return VINF_SUCCESS;
409}
410
411
412/**
413 * @opcode 0x11
414 * @oppfx 0x66
415 * @opcpuid avx
416 * @opgroup og_avx_simdfp_datamove
417 * @opxcpttype 4UA
418 * @optest op1=1 op2=2 -> op1=2
419 * @optest op1=0 op2=-22 -> op1=-22
420 */
421FNIEMOP_DEF(iemOp_vmovupd_Wpd_Vpd)
422{
423 IEMOP_MNEMONIC2(VEX_MR, VMOVUPD, vmovupd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
424 Assert(pVCpu->iem.s.uVexLength <= 1);
425 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
426 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
427 {
428 /*
429 * Register, register.
430 */
431 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
432 IEM_MC_BEGIN(0, 0);
433 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
434 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
435 if (pVCpu->iem.s.uVexLength == 0)
436 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
437 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
438 else
439 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
440 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
441 IEM_MC_ADVANCE_RIP();
442 IEM_MC_END();
443 }
444 else if (pVCpu->iem.s.uVexLength == 0)
445 {
446 /*
447 * 128-bit: Memory, register.
448 */
449 IEM_MC_BEGIN(0, 2);
450 IEM_MC_LOCAL(RTUINT128U, uSrc);
451 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
452
453 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
454 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
455 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
456 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
457
458 IEM_MC_FETCH_YREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
459 IEM_MC_STORE_MEM_U128(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
460
461 IEM_MC_ADVANCE_RIP();
462 IEM_MC_END();
463 }
464 else
465 {
466 /*
467 * 256-bit: Memory, register.
468 */
469 IEM_MC_BEGIN(0, 2);
470 IEM_MC_LOCAL(RTUINT256U, uSrc);
471 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
472
473 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
474 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
475 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
476 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
477
478 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
479 IEM_MC_STORE_MEM_U256(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
480
481 IEM_MC_ADVANCE_RIP();
482 IEM_MC_END();
483 }
484 return VINF_SUCCESS;
485}
486
487
488FNIEMOP_DEF(iemOp_vmovss_Wss_Hss_Vss)
489{
490 Assert(pVCpu->iem.s.uVexLength <= 1);
491 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
492 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
493 {
494 /**
495 * @opcode 0x11
496 * @oppfx 0xf3
497 * @opcodesub 11 mr/reg
498 * @opcpuid avx
499 * @opgroup og_avx_simdfp_datamerge
500 * @opxcpttype 5
501 * @optest op1=1 op2=0 op3=2 -> op1=2
502 * @optest op1=0 op2=0 op3=-22 -> op1=0xffffffea
503 * @optest op1=3 op2=-1 op3=0x77 -> op1=-4294967177
504 * @optest op1=3 op2=0x42 op3=0x77 -> op1=0x4200000077
505 */
506 IEMOP_MNEMONIC3(VEX_MVR_REG, VMOVSS, vmovss, Uss_WO, HssHi, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
507 IEMOP_HLP_DONE_VEX_DECODING();
508 IEM_MC_BEGIN(0, 0);
509
510 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
511 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
512 IEM_MC_MERGE_YREG_U32_U96_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB /*U32*/,
513 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
514 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hss*/);
515 IEM_MC_ADVANCE_RIP();
516 IEM_MC_END();
517 }
518 else
519 {
520 /**
521 * @opdone
522 * @opcode 0x11
523 * @oppfx 0xf3
524 * @opcodesub !11 mr/reg
525 * @opcpuid avx
526 * @opgroup og_avx_simdfp_datamove
527 * @opxcpttype 5
528 * @opfunction iemOp_vmovss_Vss_Hss_Wss
529 * @optest op1=1 op2=2 -> op1=2
530 * @optest op1=0 op2=-22 -> op1=-22
531 */
532 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVSS, vmovss, Md_WO, Vss, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
533 IEM_MC_BEGIN(0, 2);
534 IEM_MC_LOCAL(uint32_t, uSrc);
535 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
536
537 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
538 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
539 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
540 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
541
542 IEM_MC_FETCH_YREG_U32(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
543 IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
544
545 IEM_MC_ADVANCE_RIP();
546 IEM_MC_END();
547 }
548
549 return VINF_SUCCESS;
550}
551
552
553FNIEMOP_DEF(iemOp_vmovsd_Wsd_Hsd_Vsd)
554{
555 Assert(pVCpu->iem.s.uVexLength <= 1);
556 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
557 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
558 {
559 /**
560 * @opcode 0x11
561 * @oppfx 0xf2
562 * @opcodesub 11 mr/reg
563 * @opcpuid avx
564 * @opgroup og_avx_simdfp_datamerge
565 * @opxcpttype 5
566 * @optest op1=1 op2=0 op3=2 -> op1=2
567 * @optest op1=0 op2=0 op3=-22 -> op1=0xffffffffffffffea
568 * @optest op1=3 op2=-1 op3=0x77 ->
569 * op1=0xffffffffffffffff0000000000000077
570 * @optest op2=0x42 op3=0x77 -> op1=0x420000000000000077
571 */
572 IEMOP_MNEMONIC3(VEX_MVR_REG, VMOVSD, vmovsd, Usd_WO, HsdHi, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
573 IEMOP_HLP_DONE_VEX_DECODING();
574 IEM_MC_BEGIN(0, 0);
575
576 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
577 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
578 IEM_MC_MERGE_YREG_U64_U64_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
579 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
580 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hss*/);
581 IEM_MC_ADVANCE_RIP();
582 IEM_MC_END();
583 }
584 else
585 {
586 /**
587 * @opdone
588 * @opcode 0x11
589 * @oppfx 0xf2
590 * @opcodesub !11 mr/reg
591 * @opcpuid avx
592 * @opgroup og_avx_simdfp_datamove
593 * @opxcpttype 5
594 * @opfunction iemOp_vmovsd_Wsd_Hsd_Vsd
595 * @optest op1=1 op2=2 -> op1=2
596 * @optest op1=0 op2=-22 -> op1=-22
597 */
598 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVSD, vmovsd, Mq_WO, Vsd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_IGNORED);
599 IEM_MC_BEGIN(0, 2);
600 IEM_MC_LOCAL(uint64_t, uSrc);
601 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
602
603 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
604 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
605 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
606 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
607
608 IEM_MC_FETCH_YREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
609 IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
610
611 IEM_MC_ADVANCE_RIP();
612 IEM_MC_END();
613 }
614
615 return VINF_SUCCESS;
616}
617
618
619FNIEMOP_DEF(iemOp_vmovlps_Vq_Hq_Mq__vmovhlps)
620{
621 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
622 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
623 {
624 /**
625 * @opcode 0x12
626 * @opcodesub 11 mr/reg
627 * @oppfx none
628 * @opcpuid avx
629 * @opgroup og_avx_simdfp_datamerge
630 * @opxcpttype 7LZ
631 * @optest op2=0x2200220122022203
632 * op3=0x3304330533063307
633 * -> op1=0x22002201220222033304330533063307
634 * @optest op2=-1 op3=-42 -> op1=-42
635 * @note op3 and op2 are only the 8-byte high XMM register halfs.
636 */
637 IEMOP_MNEMONIC3(VEX_RVM_REG, VMOVHLPS, vmovhlps, Vq_WO, HqHi, UqHi, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
638
639 IEMOP_HLP_DONE_VEX_DECODING_L0();
640 IEM_MC_BEGIN(0, 0);
641
642 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
643 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
644 IEM_MC_MERGE_YREG_U64HI_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
645 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
646 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hq*/);
647
648 IEM_MC_ADVANCE_RIP();
649 IEM_MC_END();
650 }
651 else
652 {
653 /**
654 * @opdone
655 * @opcode 0x12
656 * @opcodesub !11 mr/reg
657 * @oppfx none
658 * @opcpuid avx
659 * @opgroup og_avx_simdfp_datamove
660 * @opxcpttype 5LZ
661 * @opfunction iemOp_vmovlps_Vq_Hq_Mq__vmovhlps
662 * @optest op1=1 op2=0 op3=0 -> op1=0
663 * @optest op1=0 op2=-1 op3=-1 -> op1=-1
664 * @optest op1=1 op2=2 op3=3 -> op1=0x20000000000000003
665 * @optest op2=-1 op3=0x42 -> op1=0xffffffffffffffff0000000000000042
666 */
667 IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPS, vmovlps, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
668
669 IEM_MC_BEGIN(0, 2);
670 IEM_MC_LOCAL(uint64_t, uSrc);
671 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
672
673 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
674 IEMOP_HLP_DONE_VEX_DECODING_L0();
675 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
676 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
677
678 IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
679 IEM_MC_MERGE_YREG_U64LOCAL_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
680 uSrc,
681 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hq*/);
682
683 IEM_MC_ADVANCE_RIP();
684 IEM_MC_END();
685 }
686 return VINF_SUCCESS;
687}
688
689
690/**
691 * @opcode 0x12
692 * @opcodesub !11 mr/reg
693 * @oppfx 0x66
694 * @opcpuid avx
695 * @opgroup og_avx_pcksclr_datamerge
696 * @opxcpttype 5LZ
697 * @optest op2=0 op3=2 -> op1=2
698 * @optest op2=0x22 op3=0x33 -> op1=0x220000000000000033
699 * @optest op2=0xfffffff0fffffff1 op3=0xeeeeeee8eeeeeee9
700 * -> op1=0xfffffff0fffffff1eeeeeee8eeeeeee9
701 */
702FNIEMOP_DEF(iemOp_vmovlpd_Vq_Hq_Mq)
703{
704 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
705 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
706 {
707 IEMOP_MNEMONIC3(VEX_RVM_MEM, VMOVLPD, vmovlpd, Vq_WO, HqHi, Mq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
708
709 IEM_MC_BEGIN(0, 2);
710 IEM_MC_LOCAL(uint64_t, uSrc);
711 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
712
713 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
714 IEMOP_HLP_DONE_VEX_DECODING_L0();
715 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
716 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
717
718 IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
719 IEM_MC_MERGE_YREG_U64LOCAL_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
720 uSrc,
721 IEM_GET_EFFECTIVE_VVVV(pVCpu) /*Hq*/);
722
723 IEM_MC_ADVANCE_RIP();
724 IEM_MC_END();
725 return VINF_SUCCESS;
726 }
727
728 /**
729 * @opdone
730 * @opmnemonic udvex660f12m3
731 * @opcode 0x12
732 * @opcodesub 11 mr/reg
733 * @oppfx 0x66
734 * @opunused immediate
735 * @opcpuid avx
736 * @optest ->
737 */
738 return IEMOP_RAISE_INVALID_OPCODE();
739}
740
741
742/**
743 * @opcode 0x12
744 * @oppfx 0xf3
745 * @opcpuid avx
746 * @opgroup og_avx_pcksclr_datamove
747 * @opxcpttype 4
748 * @optest vex.l==0 / op1=-1 op2=0xdddddddd00000002eeeeeeee00000001
749 * -> op1=0x00000002000000020000000100000001
750 * @optest vex.l==1 /
751 * op2=0xbbbbbbbb00000004cccccccc00000003dddddddd00000002eeeeeeee00000001
752 * -> op1=0x0000000400000004000000030000000300000002000000020000000100000001
753 */
754FNIEMOP_DEF(iemOp_vmovsldup_Vx_Wx)
755{
756 IEMOP_MNEMONIC2(VEX_RM, VMOVSLDUP, vmovsldup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
757 Assert(pVCpu->iem.s.uVexLength <= 1);
758 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
759 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
760 {
761 /*
762 * Register, register.
763 */
764 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
765 if (pVCpu->iem.s.uVexLength == 0)
766 {
767 IEM_MC_BEGIN(2, 0);
768 IEM_MC_ARG(PRTUINT128U, puDst, 0);
769 IEM_MC_ARG(PCRTUINT128U, puSrc, 1);
770
771 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
772 IEM_MC_PREPARE_AVX_USAGE();
773
774 IEM_MC_REF_XREG_U128_CONST(puSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
775 IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
776 IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
777 IEM_MC_CLEAR_YREG_128_UP(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
778
779 IEM_MC_ADVANCE_RIP();
780 IEM_MC_END();
781 }
782 else
783 {
784 IEM_MC_BEGIN(3, 0);
785 IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
786 IEM_MC_ARG_CONST(uint8_t, iYRegDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, 1);
787 IEM_MC_ARG_CONST(uint8_t, iYRegSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 2);
788
789 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
790 IEM_MC_PREPARE_AVX_USAGE();
791 IEM_MC_CALL_AVX_AIMPL_2(iemAImpl_vmovsldup_256_rr, iYRegDst, iYRegSrc);
792
793 IEM_MC_ADVANCE_RIP();
794 IEM_MC_END();
795 }
796 }
797 else
798 {
799 /*
800 * Register, memory.
801 */
802 if (pVCpu->iem.s.uVexLength == 0)
803 {
804 IEM_MC_BEGIN(2, 2);
805 IEM_MC_LOCAL(RTUINT128U, uSrc);
806 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
807 IEM_MC_ARG(PRTUINT128U, puDst, 0);
808 IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, puSrc, uSrc, 1);
809
810 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
811 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
812 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
813 IEM_MC_PREPARE_AVX_USAGE();
814
815 IEM_MC_FETCH_MEM_U128(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
816 IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
817 IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movsldup, puDst, puSrc);
818 IEM_MC_CLEAR_YREG_128_UP(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
819
820 IEM_MC_ADVANCE_RIP();
821 IEM_MC_END();
822 }
823 else
824 {
825 IEM_MC_BEGIN(3, 2);
826 IEM_MC_LOCAL(RTUINT256U, uSrc);
827 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
828 IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
829 IEM_MC_ARG_CONST(uint8_t, iYRegDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, 1);
830 IEM_MC_ARG_LOCAL_REF(PCRTUINT256U, puSrc, uSrc, 2);
831
832 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
833 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
834 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
835 IEM_MC_PREPARE_AVX_USAGE();
836
837 IEM_MC_FETCH_MEM_U256(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
838 IEM_MC_CALL_AVX_AIMPL_2(iemAImpl_vmovsldup_256_rm, iYRegDst, puSrc);
839
840 IEM_MC_ADVANCE_RIP();
841 IEM_MC_END();
842 }
843 }
844 return VINF_SUCCESS;
845}
846
847
848/**
849 * @opcode 0x12
850 * @oppfx 0xf2
851 * @opcpuid avx
852 * @opgroup og_avx_pcksclr_datamove
853 * @opxcpttype 5
854 * @optest vex.l==0 / op2=0xddddddddeeeeeeee2222222211111111
855 * -> op1=0x22222222111111112222222211111111
856 * @optest vex.l==1 / op2=0xbbbbbbbbcccccccc4444444433333333ddddddddeeeeeeee2222222211111111
857 * -> op1=0x4444444433333333444444443333333322222222111111112222222211111111
858 */
859FNIEMOP_DEF(iemOp_vmovddup_Vx_Wx)
860{
861 IEMOP_MNEMONIC2(VEX_RM, VMOVDDUP, vmovddup, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
862 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
863 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
864 {
865 /*
866 * Register, register.
867 */
868 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
869 if (pVCpu->iem.s.uVexLength == 0)
870 {
871 IEM_MC_BEGIN(2, 0);
872 IEM_MC_ARG(PRTUINT128U, puDst, 0);
873 IEM_MC_ARG(uint64_t, uSrc, 1);
874
875 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
876 IEM_MC_PREPARE_AVX_USAGE();
877
878 IEM_MC_FETCH_XREG_U64(uSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
879 IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
880 IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
881 IEM_MC_CLEAR_YREG_128_UP(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
882
883 IEM_MC_ADVANCE_RIP();
884 IEM_MC_END();
885 }
886 else
887 {
888 IEM_MC_BEGIN(3, 0);
889 IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
890 IEM_MC_ARG_CONST(uint8_t, iYRegDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, 1);
891 IEM_MC_ARG_CONST(uint8_t, iYRegSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, 2);
892
893 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
894 IEM_MC_PREPARE_AVX_USAGE();
895 IEM_MC_CALL_AVX_AIMPL_2(iemAImpl_vmovddup_256_rr, iYRegDst, iYRegSrc);
896
897 IEM_MC_ADVANCE_RIP();
898 IEM_MC_END();
899 }
900 }
901 else
902 {
903 /*
904 * Register, memory.
905 */
906 if (pVCpu->iem.s.uVexLength == 0)
907 {
908 IEM_MC_BEGIN(2, 2);
909 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
910 IEM_MC_ARG(PRTUINT128U, puDst, 0);
911 IEM_MC_ARG(uint64_t, uSrc, 1);
912
913 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
914 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
915 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
916 IEM_MC_PREPARE_AVX_USAGE();
917
918 IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
919 IEM_MC_REF_XREG_U128(puDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
920 IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_movddup, puDst, uSrc);
921 IEM_MC_CLEAR_YREG_128_UP(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
922
923 IEM_MC_ADVANCE_RIP();
924 IEM_MC_END();
925 }
926 else
927 {
928 IEM_MC_BEGIN(3, 2);
929 IEM_MC_LOCAL(RTUINT256U, uSrc);
930 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
931 IEM_MC_IMPLICIT_AVX_AIMPL_ARGS();
932 IEM_MC_ARG_CONST(uint8_t, iYRegDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, 1);
933 IEM_MC_ARG_LOCAL_REF(PCRTUINT256U, puSrc, uSrc, 2);
934
935 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
936 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
937 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
938 IEM_MC_PREPARE_AVX_USAGE();
939
940 IEM_MC_FETCH_MEM_U256(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
941 IEM_MC_CALL_AVX_AIMPL_2(iemAImpl_vmovddup_256_rm, iYRegDst, puSrc);
942
943 IEM_MC_ADVANCE_RIP();
944 IEM_MC_END();
945 }
946 }
947 return VINF_SUCCESS;
948}
949
950
951/**
952 * @opcode 0x13
953 * @opcodesub !11 mr/reg
954 * @oppfx none
955 * @opcpuid avx
956 * @opgroup og_avx_simdfp_datamove
957 * @opxcpttype 5
958 * @optest op1=1 op2=2 -> op1=2
959 * @optest op1=0 op2=-42 -> op1=-42
960 */
961FNIEMOP_DEF(iemOp_vmovlps_Mq_Vq)
962{
963 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
964 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
965 {
966 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPS, vmovlps, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
967
968 IEM_MC_BEGIN(0, 2);
969 IEM_MC_LOCAL(uint64_t, uSrc);
970 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
971
972 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
973 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
974 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
975 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
976
977 IEM_MC_FETCH_YREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
978 IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
979
980 IEM_MC_ADVANCE_RIP();
981 IEM_MC_END();
982 return VINF_SUCCESS;
983 }
984
985 /**
986 * @opdone
987 * @opmnemonic udvex0f13m3
988 * @opcode 0x13
989 * @opcodesub 11 mr/reg
990 * @oppfx none
991 * @opunused immediate
992 * @opcpuid avx
993 * @optest ->
994 */
995 return IEMOP_RAISE_INVALID_OPCODE();
996}
997
998
999/**
1000 * @opcode 0x13
1001 * @opcodesub !11 mr/reg
1002 * @oppfx 0x66
1003 * @opcpuid avx
1004 * @opgroup og_avx_pcksclr_datamove
1005 * @opxcpttype 5
1006 * @optest op1=1 op2=2 -> op1=2
1007 * @optest op1=0 op2=-42 -> op1=-42
1008 */
1009FNIEMOP_DEF(iemOp_vmovlpd_Mq_Vq)
1010{
1011 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1012 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
1013 {
1014 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVLPD, vmovlpd, Mq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
1015 IEM_MC_BEGIN(0, 2);
1016 IEM_MC_LOCAL(uint64_t, uSrc);
1017 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1018
1019 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1020 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
1021 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1022 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
1023
1024 IEM_MC_FETCH_YREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1025 IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1026
1027 IEM_MC_ADVANCE_RIP();
1028 IEM_MC_END();
1029 return VINF_SUCCESS;
1030 }
1031
1032 /**
1033 * @opdone
1034 * @opmnemonic udvex660f13m3
1035 * @opcode 0x13
1036 * @opcodesub 11 mr/reg
1037 * @oppfx 0x66
1038 * @opunused immediate
1039 * @opcpuid avx
1040 * @optest ->
1041 */
1042 return IEMOP_RAISE_INVALID_OPCODE();
1043}
1044
1045/* Opcode VEX.F3.0F 0x13 - invalid */
1046/* Opcode VEX.F2.0F 0x13 - invalid */
1047
1048/** Opcode VEX.0F 0x14 - vunpcklps Vx, Hx, Wx*/
1049FNIEMOP_STUB(iemOp_vunpcklps_Vx_Hx_Wx);
1050/** Opcode VEX.66.0F 0x14 - vunpcklpd Vx,Hx,Wx */
1051FNIEMOP_STUB(iemOp_vunpcklpd_Vx_Hx_Wx);
1052/* Opcode VEX.F3.0F 0x14 - invalid */
1053/* Opcode VEX.F2.0F 0x14 - invalid */
1054/** Opcode VEX.0F 0x15 - vunpckhps Vx, Hx, Wx */
1055FNIEMOP_STUB(iemOp_vunpckhps_Vx_Hx_Wx);
1056/** Opcode VEX.66.0F 0x15 - vunpckhpd Vx,Hx,Wx */
1057FNIEMOP_STUB(iemOp_vunpckhpd_Vx_Hx_Wx);
1058/* Opcode VEX.F3.0F 0x15 - invalid */
1059/* Opcode VEX.F2.0F 0x15 - invalid */
1060/** Opcode VEX.0F 0x16 - vmovhpsv1 Vdq, Hq, Mq vmovlhps Vdq, Hq, Uq */
1061FNIEMOP_STUB(iemOp_vmovhpsv1_Vdq_Hq_Mq__vmovlhps_Vdq_Hq_Uq); //NEXT
1062/** Opcode VEX.66.0F 0x16 - vmovhpdv1 Vdq, Hq, Mq */
1063FNIEMOP_STUB(iemOp_vmovhpdv1_Vdq_Hq_Mq); //NEXT
1064/** Opcode VEX.F3.0F 0x16 - vmovshdup Vx, Wx */
1065FNIEMOP_STUB(iemOp_vmovshdup_Vx_Wx); //NEXT
1066/* Opcode VEX.F2.0F 0x16 - invalid */
1067/** Opcode VEX.0F 0x17 - vmovhpsv1 Mq, Vq */
1068FNIEMOP_STUB(iemOp_vmovhpsv1_Mq_Vq); //NEXT
1069/** Opcode VEX.66.0F 0x17 - vmovhpdv1 Mq, Vq */
1070FNIEMOP_STUB(iemOp_vmovhpdv1_Mq_Vq); //NEXT
1071/* Opcode VEX.F3.0F 0x17 - invalid */
1072/* Opcode VEX.F2.0F 0x17 - invalid */
1073
1074
1075/* Opcode VEX.0F 0x18 - invalid */
1076/* Opcode VEX.0F 0x19 - invalid */
1077/* Opcode VEX.0F 0x1a - invalid */
1078/* Opcode VEX.0F 0x1b - invalid */
1079/* Opcode VEX.0F 0x1c - invalid */
1080/* Opcode VEX.0F 0x1d - invalid */
1081/* Opcode VEX.0F 0x1e - invalid */
1082/* Opcode VEX.0F 0x1f - invalid */
1083
1084/* Opcode VEX.0F 0x20 - invalid */
1085/* Opcode VEX.0F 0x21 - invalid */
1086/* Opcode VEX.0F 0x22 - invalid */
1087/* Opcode VEX.0F 0x23 - invalid */
1088/* Opcode VEX.0F 0x24 - invalid */
1089/* Opcode VEX.0F 0x25 - invalid */
1090/* Opcode VEX.0F 0x26 - invalid */
1091/* Opcode VEX.0F 0x27 - invalid */
1092
1093/**
1094 * @opcode 0x28
1095 * @oppfx none
1096 * @opcpuid avx
1097 * @opgroup og_avx_pcksclr_datamove
1098 * @opxcpttype 1
1099 * @optest op1=1 op2=2 -> op1=2
1100 * @optest op1=0 op2=-42 -> op1=-42
1101 * @note Almost identical to vmovapd.
1102 */
1103FNIEMOP_DEF(iemOp_vmovaps_Vps_Wps)
1104{
1105 IEMOP_MNEMONIC2(VEX_RM, VMOVAPS, vmovaps, Vps_WO, Wps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1106 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1107 Assert(pVCpu->iem.s.uVexLength <= 1);
1108 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1109 {
1110 /*
1111 * Register, register.
1112 */
1113 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1114 IEM_MC_BEGIN(1, 0);
1115
1116 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1117 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1118 if (pVCpu->iem.s.uVexLength == 0)
1119 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
1120 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
1121 else
1122 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
1123 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
1124 IEM_MC_ADVANCE_RIP();
1125 IEM_MC_END();
1126 }
1127 else
1128 {
1129 /*
1130 * Register, memory.
1131 */
1132 if (pVCpu->iem.s.uVexLength == 0)
1133 {
1134 IEM_MC_BEGIN(0, 2);
1135 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1136 IEM_MC_LOCAL(RTUINT128U, uSrc);
1137
1138 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1139 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1140 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1141 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1142
1143 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
1144 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
1145
1146 IEM_MC_ADVANCE_RIP();
1147 IEM_MC_END();
1148 }
1149 else
1150 {
1151 IEM_MC_BEGIN(0, 2);
1152 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1153 IEM_MC_LOCAL(RTUINT256U, uSrc);
1154
1155 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1156 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1157 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1158 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1159
1160 IEM_MC_FETCH_MEM_U256_ALIGN_AVX(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
1161 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
1162
1163 IEM_MC_ADVANCE_RIP();
1164 IEM_MC_END();
1165 }
1166 }
1167 return VINF_SUCCESS;
1168}
1169
1170
1171/**
1172 * @opcode 0x28
1173 * @oppfx 66
1174 * @opcpuid avx
1175 * @opgroup og_avx_pcksclr_datamove
1176 * @opxcpttype 1
1177 * @optest op1=1 op2=2 -> op1=2
1178 * @optest op1=0 op2=-42 -> op1=-42
1179 * @note Almost identical to vmovaps
1180 */
1181FNIEMOP_DEF(iemOp_vmovapd_Vpd_Wpd)
1182{
1183 IEMOP_MNEMONIC2(VEX_RM, VMOVAPD, vmovapd, Vpd_WO, Wpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1184 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1185 Assert(pVCpu->iem.s.uVexLength <= 1);
1186 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1187 {
1188 /*
1189 * Register, register.
1190 */
1191 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1192 IEM_MC_BEGIN(1, 0);
1193
1194 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1195 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1196 if (pVCpu->iem.s.uVexLength == 0)
1197 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
1198 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
1199 else
1200 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
1201 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
1202 IEM_MC_ADVANCE_RIP();
1203 IEM_MC_END();
1204 }
1205 else
1206 {
1207 /*
1208 * Register, memory.
1209 */
1210 if (pVCpu->iem.s.uVexLength == 0)
1211 {
1212 IEM_MC_BEGIN(0, 2);
1213 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1214 IEM_MC_LOCAL(RTUINT128U, uSrc);
1215
1216 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1217 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1218 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1219 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1220
1221 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
1222 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
1223
1224 IEM_MC_ADVANCE_RIP();
1225 IEM_MC_END();
1226 }
1227 else
1228 {
1229 IEM_MC_BEGIN(0, 2);
1230 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1231 IEM_MC_LOCAL(RTUINT256U, uSrc);
1232
1233 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1234 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1235 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1236 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1237
1238 IEM_MC_FETCH_MEM_U256_ALIGN_AVX(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
1239 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
1240
1241 IEM_MC_ADVANCE_RIP();
1242 IEM_MC_END();
1243 }
1244 }
1245 return VINF_SUCCESS;
1246}
1247
1248/**
1249 * @opmnemonic udvexf30f28
1250 * @opcode 0x28
1251 * @oppfx 0xf3
1252 * @opunused vex.modrm
1253 * @opcpuid avx
1254 * @optest ->
1255 * @opdone
1256 */
1257
1258/**
1259 * @opmnemonic udvexf20f28
1260 * @opcode 0x28
1261 * @oppfx 0xf2
1262 * @opunused vex.modrm
1263 * @opcpuid avx
1264 * @optest ->
1265 * @opdone
1266 */
1267
1268/**
1269 * @opcode 0x29
1270 * @oppfx none
1271 * @opcpuid avx
1272 * @opgroup og_avx_pcksclr_datamove
1273 * @opxcpttype 1
1274 * @optest op1=1 op2=2 -> op1=2
1275 * @optest op1=0 op2=-42 -> op1=-42
1276 * @note Almost identical to vmovapd.
1277 */
1278FNIEMOP_DEF(iemOp_vmovaps_Wps_Vps)
1279{
1280 IEMOP_MNEMONIC2(VEX_MR, VMOVAPS, vmovaps, Wps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1281 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1282 Assert(pVCpu->iem.s.uVexLength <= 1);
1283 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1284 {
1285 /*
1286 * Register, register.
1287 */
1288 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1289 IEM_MC_BEGIN(1, 0);
1290
1291 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1292 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1293 if (pVCpu->iem.s.uVexLength == 0)
1294 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
1295 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1296 else
1297 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
1298 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1299 IEM_MC_ADVANCE_RIP();
1300 IEM_MC_END();
1301 }
1302 else
1303 {
1304 /*
1305 * Register, memory.
1306 */
1307 if (pVCpu->iem.s.uVexLength == 0)
1308 {
1309 IEM_MC_BEGIN(0, 2);
1310 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1311 IEM_MC_LOCAL(RTUINT128U, uSrc);
1312
1313 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1314 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1315 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1316 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
1317
1318 IEM_MC_FETCH_YREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1319 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1320
1321 IEM_MC_ADVANCE_RIP();
1322 IEM_MC_END();
1323 }
1324 else
1325 {
1326 IEM_MC_BEGIN(0, 2);
1327 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1328 IEM_MC_LOCAL(RTUINT256U, uSrc);
1329
1330 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1331 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1332 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1333 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
1334
1335 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1336 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1337
1338 IEM_MC_ADVANCE_RIP();
1339 IEM_MC_END();
1340 }
1341 }
1342 return VINF_SUCCESS;
1343}
1344
1345/**
1346 * @opcode 0x29
1347 * @oppfx 66
1348 * @opcpuid avx
1349 * @opgroup og_avx_pcksclr_datamove
1350 * @opxcpttype 1
1351 * @optest op1=1 op2=2 -> op1=2
1352 * @optest op1=0 op2=-42 -> op1=-42
1353 * @note Almost identical to vmovaps
1354 */
1355FNIEMOP_DEF(iemOp_vmovapd_Wpd_Vpd)
1356{
1357 IEMOP_MNEMONIC2(VEX_MR, VMOVAPD, vmovapd, Wpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1358 Assert(pVCpu->iem.s.uVexLength <= 1);
1359 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1360 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1361 {
1362 /*
1363 * Register, register.
1364 */
1365 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1366 IEM_MC_BEGIN(1, 0);
1367
1368 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1369 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1370 if (pVCpu->iem.s.uVexLength == 0)
1371 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
1372 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1373 else
1374 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
1375 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1376 IEM_MC_ADVANCE_RIP();
1377 IEM_MC_END();
1378 }
1379 else
1380 {
1381 /*
1382 * Register, memory.
1383 */
1384 if (pVCpu->iem.s.uVexLength == 0)
1385 {
1386 IEM_MC_BEGIN(0, 2);
1387 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1388 IEM_MC_LOCAL(RTUINT128U, uSrc);
1389
1390 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1391 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1392 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1393 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
1394
1395 IEM_MC_FETCH_YREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1396 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1397
1398 IEM_MC_ADVANCE_RIP();
1399 IEM_MC_END();
1400 }
1401 else
1402 {
1403 IEM_MC_BEGIN(0, 2);
1404 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1405 IEM_MC_LOCAL(RTUINT256U, uSrc);
1406
1407 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1408 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1409 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1410 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
1411
1412 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1413 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1414
1415 IEM_MC_ADVANCE_RIP();
1416 IEM_MC_END();
1417 }
1418 }
1419 return VINF_SUCCESS;
1420}
1421
1422
1423/**
1424 * @opmnemonic udvexf30f29
1425 * @opcode 0x29
1426 * @oppfx 0xf3
1427 * @opunused vex.modrm
1428 * @opcpuid avx
1429 * @optest ->
1430 * @opdone
1431 */
1432
1433/**
1434 * @opmnemonic udvexf20f29
1435 * @opcode 0x29
1436 * @oppfx 0xf2
1437 * @opunused vex.modrm
1438 * @opcpuid avx
1439 * @optest ->
1440 * @opdone
1441 */
1442
1443
1444/** Opcode VEX.0F 0x2a - invalid */
1445/** Opcode VEX.66.0F 0x2a - invalid */
1446/** Opcode VEX.F3.0F 0x2a - vcvtsi2ss Vss, Hss, Ey */
1447FNIEMOP_STUB(iemOp_vcvtsi2ss_Vss_Hss_Ey);
1448/** Opcode VEX.F2.0F 0x2a - vcvtsi2sd Vsd, Hsd, Ey */
1449FNIEMOP_STUB(iemOp_vcvtsi2sd_Vsd_Hsd_Ey);
1450
1451
1452/**
1453 * @opcode 0x2b
1454 * @opcodesub !11 mr/reg
1455 * @oppfx none
1456 * @opcpuid avx
1457 * @opgroup og_avx_cachect
1458 * @opxcpttype 1
1459 * @optest op1=1 op2=2 -> op1=2
1460 * @optest op1=0 op2=-42 -> op1=-42
1461 * @note Identical implementation to vmovntpd
1462 */
1463FNIEMOP_DEF(iemOp_vmovntps_Mps_Vps)
1464{
1465 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPS, vmovntps, Mps_WO, Vps, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1466 Assert(pVCpu->iem.s.uVexLength <= 1);
1467 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1468 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
1469 {
1470 /*
1471 * memory, register.
1472 */
1473 if (pVCpu->iem.s.uVexLength == 0)
1474 {
1475 IEM_MC_BEGIN(0, 2);
1476 IEM_MC_LOCAL(RTUINT128U, uSrc);
1477 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1478
1479 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1480 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1481 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1482 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1483
1484 IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1485 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1486
1487 IEM_MC_ADVANCE_RIP();
1488 IEM_MC_END();
1489 }
1490 else
1491 {
1492 IEM_MC_BEGIN(0, 2);
1493 IEM_MC_LOCAL(RTUINT256U, uSrc);
1494 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1495
1496 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1497 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1498 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1499 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1500
1501 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1502 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1503
1504 IEM_MC_ADVANCE_RIP();
1505 IEM_MC_END();
1506 }
1507 }
1508 /* The register, register encoding is invalid. */
1509 else
1510 return IEMOP_RAISE_INVALID_OPCODE();
1511 return VINF_SUCCESS;
1512}
1513
1514/**
1515 * @opcode 0x2b
1516 * @opcodesub !11 mr/reg
1517 * @oppfx 0x66
1518 * @opcpuid avx
1519 * @opgroup og_avx_cachect
1520 * @opxcpttype 1
1521 * @optest op1=1 op2=2 -> op1=2
1522 * @optest op1=0 op2=-42 -> op1=-42
1523 * @note Identical implementation to vmovntps
1524 */
1525FNIEMOP_DEF(iemOp_vmovntpd_Mpd_Vpd)
1526{
1527 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTPD, vmovntpd, Mpd_WO, Vpd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
1528 Assert(pVCpu->iem.s.uVexLength <= 1);
1529 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1530 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
1531 {
1532 /*
1533 * memory, register.
1534 */
1535 if (pVCpu->iem.s.uVexLength == 0)
1536 {
1537 IEM_MC_BEGIN(0, 2);
1538 IEM_MC_LOCAL(RTUINT128U, uSrc);
1539 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1540
1541 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1542 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1543 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1544 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1545
1546 IEM_MC_FETCH_XREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1547 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1548
1549 IEM_MC_ADVANCE_RIP();
1550 IEM_MC_END();
1551 }
1552 else
1553 {
1554 IEM_MC_BEGIN(0, 2);
1555 IEM_MC_LOCAL(RTUINT256U, uSrc);
1556 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1557
1558 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1559 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
1560 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
1561 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
1562
1563 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1564 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
1565
1566 IEM_MC_ADVANCE_RIP();
1567 IEM_MC_END();
1568 }
1569 }
1570 /* The register, register encoding is invalid. */
1571 else
1572 return IEMOP_RAISE_INVALID_OPCODE();
1573 return VINF_SUCCESS;
1574}
1575
1576/**
1577 * @opmnemonic udvexf30f2b
1578 * @opcode 0x2b
1579 * @oppfx 0xf3
1580 * @opunused vex.modrm
1581 * @opcpuid avx
1582 * @optest ->
1583 * @opdone
1584 */
1585
1586/**
1587 * @opmnemonic udvexf20f2b
1588 * @opcode 0x2b
1589 * @oppfx 0xf2
1590 * @opunused vex.modrm
1591 * @opcpuid avx
1592 * @optest ->
1593 * @opdone
1594 */
1595
1596
1597/* Opcode VEX.0F 0x2c - invalid */
1598/* Opcode VEX.66.0F 0x2c - invalid */
1599/** Opcode VEX.F3.0F 0x2c - vcvttss2si Gy, Wss */
1600FNIEMOP_STUB(iemOp_vcvttss2si_Gy_Wss);
1601/** Opcode VEX.F2.0F 0x2c - vcvttsd2si Gy, Wsd */
1602FNIEMOP_STUB(iemOp_vcvttsd2si_Gy_Wsd);
1603
1604/* Opcode VEX.0F 0x2d - invalid */
1605/* Opcode VEX.66.0F 0x2d - invalid */
1606/** Opcode VEX.F3.0F 0x2d - vcvtss2si Gy, Wss */
1607FNIEMOP_STUB(iemOp_vcvtss2si_Gy_Wss);
1608/** Opcode VEX.F2.0F 0x2d - vcvtsd2si Gy, Wsd */
1609FNIEMOP_STUB(iemOp_vcvtsd2si_Gy_Wsd);
1610
1611/** Opcode VEX.0F 0x2e - vucomiss Vss, Wss */
1612FNIEMOP_STUB(iemOp_vucomiss_Vss_Wss);
1613/** Opcode VEX.66.0F 0x2e - vucomisd Vsd, Wsd */
1614FNIEMOP_STUB(iemOp_vucomisd_Vsd_Wsd);
1615/* Opcode VEX.F3.0F 0x2e - invalid */
1616/* Opcode VEX.F2.0F 0x2e - invalid */
1617
1618/** Opcode VEX.0F 0x2f - vcomiss Vss, Wss */
1619FNIEMOP_STUB(iemOp_vcomiss_Vss_Wss);
1620/** Opcode VEX.66.0F 0x2f - vcomisd Vsd, Wsd */
1621FNIEMOP_STUB(iemOp_vcomisd_Vsd_Wsd);
1622/* Opcode VEX.F3.0F 0x2f - invalid */
1623/* Opcode VEX.F2.0F 0x2f - invalid */
1624
1625/* Opcode VEX.0F 0x30 - invalid */
1626/* Opcode VEX.0F 0x31 - invalid */
1627/* Opcode VEX.0F 0x32 - invalid */
1628/* Opcode VEX.0F 0x33 - invalid */
1629/* Opcode VEX.0F 0x34 - invalid */
1630/* Opcode VEX.0F 0x35 - invalid */
1631/* Opcode VEX.0F 0x36 - invalid */
1632/* Opcode VEX.0F 0x37 - invalid */
1633/* Opcode VEX.0F 0x38 - invalid */
1634/* Opcode VEX.0F 0x39 - invalid */
1635/* Opcode VEX.0F 0x3a - invalid */
1636/* Opcode VEX.0F 0x3b - invalid */
1637/* Opcode VEX.0F 0x3c - invalid */
1638/* Opcode VEX.0F 0x3d - invalid */
1639/* Opcode VEX.0F 0x3e - invalid */
1640/* Opcode VEX.0F 0x3f - invalid */
1641/* Opcode VEX.0F 0x40 - invalid */
1642/* Opcode VEX.0F 0x41 - invalid */
1643/* Opcode VEX.0F 0x42 - invalid */
1644/* Opcode VEX.0F 0x43 - invalid */
1645/* Opcode VEX.0F 0x44 - invalid */
1646/* Opcode VEX.0F 0x45 - invalid */
1647/* Opcode VEX.0F 0x46 - invalid */
1648/* Opcode VEX.0F 0x47 - invalid */
1649/* Opcode VEX.0F 0x48 - invalid */
1650/* Opcode VEX.0F 0x49 - invalid */
1651/* Opcode VEX.0F 0x4a - invalid */
1652/* Opcode VEX.0F 0x4b - invalid */
1653/* Opcode VEX.0F 0x4c - invalid */
1654/* Opcode VEX.0F 0x4d - invalid */
1655/* Opcode VEX.0F 0x4e - invalid */
1656/* Opcode VEX.0F 0x4f - invalid */
1657
1658/** Opcode VEX.0F 0x50 - vmovmskps Gy, Ups */
1659FNIEMOP_STUB(iemOp_vmovmskps_Gy_Ups);
1660/** Opcode VEX.66.0F 0x50 - vmovmskpd Gy,Upd */
1661FNIEMOP_STUB(iemOp_vmovmskpd_Gy_Upd);
1662/* Opcode VEX.F3.0F 0x50 - invalid */
1663/* Opcode VEX.F2.0F 0x50 - invalid */
1664
1665/** Opcode VEX.0F 0x51 - vsqrtps Vps, Wps */
1666FNIEMOP_STUB(iemOp_vsqrtps_Vps_Wps);
1667/** Opcode VEX.66.0F 0x51 - vsqrtpd Vpd, Wpd */
1668FNIEMOP_STUB(iemOp_vsqrtpd_Vpd_Wpd);
1669/** Opcode VEX.F3.0F 0x51 - vsqrtss Vss, Hss, Wss */
1670FNIEMOP_STUB(iemOp_vsqrtss_Vss_Hss_Wss);
1671/** Opcode VEX.F2.0F 0x51 - vsqrtsd Vsd, Hsd, Wsd */
1672FNIEMOP_STUB(iemOp_vsqrtsd_Vsd_Hsd_Wsd);
1673
1674/** Opcode VEX.0F 0x52 - vrsqrtps Vps, Wps */
1675FNIEMOP_STUB(iemOp_vrsqrtps_Vps_Wps);
1676/* Opcode VEX.66.0F 0x52 - invalid */
1677/** Opcode VEX.F3.0F 0x52 - vrsqrtss Vss, Hss, Wss */
1678FNIEMOP_STUB(iemOp_vrsqrtss_Vss_Hss_Wss);
1679/* Opcode VEX.F2.0F 0x52 - invalid */
1680
1681/** Opcode VEX.0F 0x53 - vrcpps Vps, Wps */
1682FNIEMOP_STUB(iemOp_vrcpps_Vps_Wps);
1683/* Opcode VEX.66.0F 0x53 - invalid */
1684/** Opcode VEX.F3.0F 0x53 - vrcpss Vss, Hss, Wss */
1685FNIEMOP_STUB(iemOp_vrcpss_Vss_Hss_Wss);
1686/* Opcode VEX.F2.0F 0x53 - invalid */
1687
1688/** Opcode VEX.0F 0x54 - vandps Vps, Hps, Wps */
1689FNIEMOP_STUB(iemOp_vandps_Vps_Hps_Wps);
1690/** Opcode VEX.66.0F 0x54 - vandpd Vpd, Hpd, Wpd */
1691FNIEMOP_STUB(iemOp_vandpd_Vpd_Hpd_Wpd);
1692/* Opcode VEX.F3.0F 0x54 - invalid */
1693/* Opcode VEX.F2.0F 0x54 - invalid */
1694
1695/** Opcode VEX.0F 0x55 - vandnps Vps, Hps, Wps */
1696FNIEMOP_STUB(iemOp_vandnps_Vps_Hps_Wps);
1697/** Opcode VEX.66.0F 0x55 - vandnpd Vpd, Hpd, Wpd */
1698FNIEMOP_STUB(iemOp_vandnpd_Vpd_Hpd_Wpd);
1699/* Opcode VEX.F3.0F 0x55 - invalid */
1700/* Opcode VEX.F2.0F 0x55 - invalid */
1701
1702/** Opcode VEX.0F 0x56 - vorps Vps, Hps, Wps */
1703FNIEMOP_STUB(iemOp_vorps_Vps_Hps_Wps);
1704/** Opcode VEX.66.0F 0x56 - vorpd Vpd, Hpd, Wpd */
1705FNIEMOP_STUB(iemOp_vorpd_Vpd_Hpd_Wpd);
1706/* Opcode VEX.F3.0F 0x56 - invalid */
1707/* Opcode VEX.F2.0F 0x56 - invalid */
1708
1709/** Opcode VEX.0F 0x57 - vxorps Vps, Hps, Wps */
1710FNIEMOP_STUB(iemOp_vxorps_Vps_Hps_Wps);
1711/** Opcode VEX.66.0F 0x57 - vxorpd Vpd, Hpd, Wpd */
1712FNIEMOP_STUB(iemOp_vxorpd_Vpd_Hpd_Wpd);
1713/* Opcode VEX.F3.0F 0x57 - invalid */
1714/* Opcode VEX.F2.0F 0x57 - invalid */
1715
1716/** Opcode VEX.0F 0x58 - vaddps Vps, Hps, Wps */
1717FNIEMOP_STUB(iemOp_vaddps_Vps_Hps_Wps);
1718/** Opcode VEX.66.0F 0x58 - vaddpd Vpd, Hpd, Wpd */
1719FNIEMOP_STUB(iemOp_vaddpd_Vpd_Hpd_Wpd);
1720/** Opcode VEX.F3.0F 0x58 - vaddss Vss, Hss, Wss */
1721FNIEMOP_STUB(iemOp_vaddss_Vss_Hss_Wss);
1722/** Opcode VEX.F2.0F 0x58 - vaddsd Vsd, Hsd, Wsd */
1723FNIEMOP_STUB(iemOp_vaddsd_Vsd_Hsd_Wsd);
1724
1725/** Opcode VEX.0F 0x59 - vmulps Vps, Hps, Wps */
1726FNIEMOP_STUB(iemOp_vmulps_Vps_Hps_Wps);
1727/** Opcode VEX.66.0F 0x59 - vmulpd Vpd, Hpd, Wpd */
1728FNIEMOP_STUB(iemOp_vmulpd_Vpd_Hpd_Wpd);
1729/** Opcode VEX.F3.0F 0x59 - vmulss Vss, Hss, Wss */
1730FNIEMOP_STUB(iemOp_vmulss_Vss_Hss_Wss);
1731/** Opcode VEX.F2.0F 0x59 - vmulsd Vsd, Hsd, Wsd */
1732FNIEMOP_STUB(iemOp_vmulsd_Vsd_Hsd_Wsd);
1733
1734/** Opcode VEX.0F 0x5a - vcvtps2pd Vpd, Wps */
1735FNIEMOP_STUB(iemOp_vcvtps2pd_Vpd_Wps);
1736/** Opcode VEX.66.0F 0x5a - vcvtpd2ps Vps, Wpd */
1737FNIEMOP_STUB(iemOp_vcvtpd2ps_Vps_Wpd);
1738/** Opcode VEX.F3.0F 0x5a - vcvtss2sd Vsd, Hx, Wss */
1739FNIEMOP_STUB(iemOp_vcvtss2sd_Vsd_Hx_Wss);
1740/** Opcode VEX.F2.0F 0x5a - vcvtsd2ss Vss, Hx, Wsd */
1741FNIEMOP_STUB(iemOp_vcvtsd2ss_Vss_Hx_Wsd);
1742
1743/** Opcode VEX.0F 0x5b - vcvtdq2ps Vps, Wdq */
1744FNIEMOP_STUB(iemOp_vcvtdq2ps_Vps_Wdq);
1745/** Opcode VEX.66.0F 0x5b - vcvtps2dq Vdq, Wps */
1746FNIEMOP_STUB(iemOp_vcvtps2dq_Vdq_Wps);
1747/** Opcode VEX.F3.0F 0x5b - vcvttps2dq Vdq, Wps */
1748FNIEMOP_STUB(iemOp_vcvttps2dq_Vdq_Wps);
1749/* Opcode VEX.F2.0F 0x5b - invalid */
1750
1751/** Opcode VEX.0F 0x5c - vsubps Vps, Hps, Wps */
1752FNIEMOP_STUB(iemOp_vsubps_Vps_Hps_Wps);
1753/** Opcode VEX.66.0F 0x5c - vsubpd Vpd, Hpd, Wpd */
1754FNIEMOP_STUB(iemOp_vsubpd_Vpd_Hpd_Wpd);
1755/** Opcode VEX.F3.0F 0x5c - vsubss Vss, Hss, Wss */
1756FNIEMOP_STUB(iemOp_vsubss_Vss_Hss_Wss);
1757/** Opcode VEX.F2.0F 0x5c - vsubsd Vsd, Hsd, Wsd */
1758FNIEMOP_STUB(iemOp_vsubsd_Vsd_Hsd_Wsd);
1759
1760/** Opcode VEX.0F 0x5d - vminps Vps, Hps, Wps */
1761FNIEMOP_STUB(iemOp_vminps_Vps_Hps_Wps);
1762/** Opcode VEX.66.0F 0x5d - vminpd Vpd, Hpd, Wpd */
1763FNIEMOP_STUB(iemOp_vminpd_Vpd_Hpd_Wpd);
1764/** Opcode VEX.F3.0F 0x5d - vminss Vss, Hss, Wss */
1765FNIEMOP_STUB(iemOp_vminss_Vss_Hss_Wss);
1766/** Opcode VEX.F2.0F 0x5d - vminsd Vsd, Hsd, Wsd */
1767FNIEMOP_STUB(iemOp_vminsd_Vsd_Hsd_Wsd);
1768
1769/** Opcode VEX.0F 0x5e - vdivps Vps, Hps, Wps */
1770FNIEMOP_STUB(iemOp_vdivps_Vps_Hps_Wps);
1771/** Opcode VEX.66.0F 0x5e - vdivpd Vpd, Hpd, Wpd */
1772FNIEMOP_STUB(iemOp_vdivpd_Vpd_Hpd_Wpd);
1773/** Opcode VEX.F3.0F 0x5e - vdivss Vss, Hss, Wss */
1774FNIEMOP_STUB(iemOp_vdivss_Vss_Hss_Wss);
1775/** Opcode VEX.F2.0F 0x5e - vdivsd Vsd, Hsd, Wsd */
1776FNIEMOP_STUB(iemOp_vdivsd_Vsd_Hsd_Wsd);
1777
1778/** Opcode VEX.0F 0x5f - vmaxps Vps, Hps, Wps */
1779FNIEMOP_STUB(iemOp_vmaxps_Vps_Hps_Wps);
1780/** Opcode VEX.66.0F 0x5f - vmaxpd Vpd, Hpd, Wpd */
1781FNIEMOP_STUB(iemOp_vmaxpd_Vpd_Hpd_Wpd);
1782/** Opcode VEX.F3.0F 0x5f - vmaxss Vss, Hss, Wss */
1783FNIEMOP_STUB(iemOp_vmaxss_Vss_Hss_Wss);
1784/** Opcode VEX.F2.0F 0x5f - vmaxsd Vsd, Hsd, Wsd */
1785FNIEMOP_STUB(iemOp_vmaxsd_Vsd_Hsd_Wsd);
1786
1787
1788///**
1789// * Common worker for SSE2 instructions on the forms:
1790// * pxxxx xmm1, xmm2/mem128
1791// *
1792// * The 2nd operand is the first half of a register, which in the memory case
1793// * means a 32-bit memory access for MMX and 128-bit aligned 64-bit or 128-bit
1794// * memory accessed for MMX.
1795// *
1796// * Exceptions type 4.
1797// */
1798//FNIEMOP_DEF_1(iemOpCommonSse_LowLow_To_Full, PCIEMOPMEDIAF1L1, pImpl)
1799//{
1800// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1801// if (!pImpl->pfnU64)
1802// return IEMOP_RAISE_INVALID_OPCODE();
1803// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1804// {
1805// /*
1806// * Register, register.
1807// */
1808// /** @todo testcase: REX.B / REX.R and MMX register indexing. Ignored? */
1809// /** @todo testcase: REX.B / REX.R and segment register indexing. Ignored? */
1810// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
1811// IEM_MC_BEGIN(2, 0);
1812// IEM_MC_ARG(uint64_t *, pDst, 0);
1813// IEM_MC_ARG(uint32_t const *, pSrc, 1);
1814// IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
1815// IEM_MC_PREPARE_FPU_USAGE();
1816// IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
1817// IEM_MC_REF_MREG_U32_CONST(pSrc, bRm & X86_MODRM_RM_MASK);
1818// IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
1819// IEM_MC_ADVANCE_RIP();
1820// IEM_MC_END();
1821// }
1822// else
1823// {
1824// /*
1825// * Register, memory.
1826// */
1827// IEM_MC_BEGIN(2, 2);
1828// IEM_MC_ARG(uint64_t *, pDst, 0);
1829// IEM_MC_LOCAL(uint32_t, uSrc);
1830// IEM_MC_ARG_LOCAL_REF(uint32_t const *, pSrc, uSrc, 1);
1831// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1832//
1833// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1834// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
1835// IEM_MC_MAYBE_RAISE_MMX_RELATED_XCPT();
1836// IEM_MC_FETCH_MEM_U32(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
1837//
1838// IEM_MC_PREPARE_FPU_USAGE();
1839// IEM_MC_REF_MREG_U64(pDst, (bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK);
1840// IEM_MC_CALL_MMX_AIMPL_2(pImpl->pfnU64, pDst, pSrc);
1841//
1842// IEM_MC_ADVANCE_RIP();
1843// IEM_MC_END();
1844// }
1845// return VINF_SUCCESS;
1846//}
1847
1848
1849/* Opcode VEX.0F 0x60 - invalid */
1850
1851/** Opcode VEX.66.0F 0x60 - vpunpcklbw Vx, Hx, W */
1852FNIEMOP_STUB(iemOp_vpunpcklbw_Vx_Hx_Wx);
1853//FNIEMOP_DEF(iemOp_vpunpcklbw_Vx_Hx_Wx)
1854//{
1855// IEMOP_MNEMONIC(vpunpcklbw, "vpunpcklbw Vx, Hx, Wx");
1856// return FNIEMOP_CALL_1(iemOpCommonSse_LowLow_To_Full, &g_iemAImpl_punpcklbw);
1857//}
1858
1859/* Opcode VEX.F3.0F 0x60 - invalid */
1860
1861
1862/* Opcode VEX.0F 0x61 - invalid */
1863
1864/** Opcode VEX.66.0F 0x61 - vpunpcklwd Vx, Hx, Wx */
1865FNIEMOP_STUB(iemOp_vpunpcklwd_Vx_Hx_Wx);
1866//FNIEMOP_DEF(iemOp_vpunpcklwd_Vx_Hx_Wx)
1867//{
1868// IEMOP_MNEMONIC(vpunpcklwd, "vpunpcklwd Vx, Hx, Wx");
1869// return FNIEMOP_CALL_1(iemOpCommonSse_LowLow_To_Full, &g_iemAImpl_punpcklwd);
1870//}
1871
1872/* Opcode VEX.F3.0F 0x61 - invalid */
1873
1874
1875/* Opcode VEX.0F 0x62 - invalid */
1876
1877/** Opcode VEX.66.0F 0x62 - vpunpckldq Vx, Hx, Wx */
1878FNIEMOP_STUB(iemOp_vpunpckldq_Vx_Hx_Wx);
1879//FNIEMOP_DEF(iemOp_vpunpckldq_Vx_Hx_Wx)
1880//{
1881// IEMOP_MNEMONIC(vpunpckldq, "vpunpckldq Vx, Hx, Wx");
1882// return FNIEMOP_CALL_1(iemOpCommonSse_LowLow_To_Full, &g_iemAImpl_punpckldq);
1883//}
1884
1885/* Opcode VEX.F3.0F 0x62 - invalid */
1886
1887
1888
1889/* Opcode VEX.0F 0x63 - invalid */
1890/** Opcode VEX.66.0F 0x63 - vpacksswb Vx, Hx, Wx */
1891FNIEMOP_STUB(iemOp_vpacksswb_Vx_Hx_Wx);
1892/* Opcode VEX.F3.0F 0x63 - invalid */
1893
1894/* Opcode VEX.0F 0x64 - invalid */
1895/** Opcode VEX.66.0F 0x64 - vpcmpgtb Vx, Hx, Wx */
1896FNIEMOP_STUB(iemOp_vpcmpgtb_Vx_Hx_Wx);
1897/* Opcode VEX.F3.0F 0x64 - invalid */
1898
1899/* Opcode VEX.0F 0x65 - invalid */
1900/** Opcode VEX.66.0F 0x65 - vpcmpgtw Vx, Hx, Wx */
1901FNIEMOP_STUB(iemOp_vpcmpgtw_Vx_Hx_Wx);
1902/* Opcode VEX.F3.0F 0x65 - invalid */
1903
1904/* Opcode VEX.0F 0x66 - invalid */
1905/** Opcode VEX.66.0F 0x66 - vpcmpgtd Vx, Hx, Wx */
1906FNIEMOP_STUB(iemOp_vpcmpgtd_Vx_Hx_Wx);
1907/* Opcode VEX.F3.0F 0x66 - invalid */
1908
1909/* Opcode VEX.0F 0x67 - invalid */
1910/** Opcode VEX.66.0F 0x67 - vpackuswb Vx, Hx, W */
1911FNIEMOP_STUB(iemOp_vpackuswb_Vx_Hx_W);
1912/* Opcode VEX.F3.0F 0x67 - invalid */
1913
1914
1915///**
1916// * Common worker for SSE2 instructions on the form:
1917// * pxxxx xmm1, xmm2/mem128
1918// *
1919// * The 2nd operand is the second half of a register, which in the memory case
1920// * means a 64-bit memory access for MMX, and for SSE a 128-bit aligned access
1921// * where it may read the full 128 bits or only the upper 64 bits.
1922// *
1923// * Exceptions type 4.
1924// */
1925//FNIEMOP_DEF_1(iemOpCommonSse_HighHigh_To_Full, PCIEMOPMEDIAF1H1, pImpl)
1926//{
1927// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
1928// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
1929// {
1930// /*
1931// * Register, register.
1932// */
1933// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
1934// IEM_MC_BEGIN(2, 0);
1935// IEM_MC_ARG(PRTUINT128U, pDst, 0);
1936// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
1937// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
1938// IEM_MC_PREPARE_SSE_USAGE();
1939// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1940// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
1941// IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
1942// IEM_MC_ADVANCE_RIP();
1943// IEM_MC_END();
1944// }
1945// else
1946// {
1947// /*
1948// * Register, memory.
1949// */
1950// IEM_MC_BEGIN(2, 2);
1951// IEM_MC_ARG(PRTUINT128U, pDst, 0);
1952// IEM_MC_LOCAL(RTUINT128U, uSrc);
1953// IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, pSrc, uSrc, 1);
1954// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
1955//
1956// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
1957// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
1958// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
1959// IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc); /* Most CPUs probably only right high qword */
1960//
1961// IEM_MC_PREPARE_SSE_USAGE();
1962// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
1963// IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
1964//
1965// IEM_MC_ADVANCE_RIP();
1966// IEM_MC_END();
1967// }
1968// return VINF_SUCCESS;
1969//}
1970
1971
1972/* Opcode VEX.0F 0x68 - invalid */
1973
1974/** Opcode VEX.66.0F 0x68 - vpunpckhbw Vx, Hx, Wx */
1975FNIEMOP_STUB(iemOp_vpunpckhbw_Vx_Hx_Wx);
1976//FNIEMOP_DEF(iemOp_vpunpckhbw_Vx_Hx_Wx)
1977//{
1978// IEMOP_MNEMONIC(vpunpckhbw, "vpunpckhbw Vx, Hx, Wx");
1979// return FNIEMOP_CALL_1(iemOpCommonSse_HighHigh_To_Full, &g_iemAImpl_punpckhbw);
1980//}
1981/* Opcode VEX.F3.0F 0x68 - invalid */
1982
1983
1984/* Opcode VEX.0F 0x69 - invalid */
1985
1986/** Opcode VEX.66.0F 0x69 - vpunpckhwd Vx, Hx, Wx */
1987FNIEMOP_STUB(iemOp_vpunpckhwd_Vx_Hx_Wx);
1988//FNIEMOP_DEF(iemOp_vpunpckhwd_Vx_Hx_Wx)
1989//{
1990// IEMOP_MNEMONIC(vpunpckhwd, "vpunpckhwd Vx, Hx, Wx");
1991// return FNIEMOP_CALL_1(iemOpCommonSse_HighHigh_To_Full, &g_iemAImpl_punpckhwd);
1992//
1993//}
1994/* Opcode VEX.F3.0F 0x69 - invalid */
1995
1996
1997/* Opcode VEX.0F 0x6a - invalid */
1998
1999/** Opcode VEX.66.0F 0x6a - vpunpckhdq Vx, Hx, W */
2000FNIEMOP_STUB(iemOp_vpunpckhdq_Vx_Hx_W);
2001//FNIEMOP_DEF(iemOp_vpunpckhdq_Vx_Hx_W)
2002//{
2003// IEMOP_MNEMONIC(vpunpckhdq, "vpunpckhdq Vx, Hx, W");
2004// return FNIEMOP_CALL_1(iemOpCommonSse_HighHigh_To_Full, &g_iemAImpl_punpckhdq);
2005//}
2006/* Opcode VEX.F3.0F 0x6a - invalid */
2007
2008
2009/* Opcode VEX.0F 0x6b - invalid */
2010/** Opcode VEX.66.0F 0x6b - vpackssdw Vx, Hx, Wx */
2011FNIEMOP_STUB(iemOp_vpackssdw_Vx_Hx_Wx);
2012/* Opcode VEX.F3.0F 0x6b - invalid */
2013
2014
2015/* Opcode VEX.0F 0x6c - invalid */
2016
2017/** Opcode VEX.66.0F 0x6c - vpunpcklqdq Vx, Hx, Wx */
2018FNIEMOP_STUB(iemOp_vpunpcklqdq_Vx_Hx_Wx);
2019//FNIEMOP_DEF(iemOp_vpunpcklqdq_Vx_Hx_Wx)
2020//{
2021// IEMOP_MNEMONIC(vpunpcklqdq, "vpunpcklqdq Vx, Hx, Wx");
2022// return FNIEMOP_CALL_1(iemOpCommonSse_LowLow_To_Full, &g_iemAImpl_punpcklqdq);
2023//}
2024
2025/* Opcode VEX.F3.0F 0x6c - invalid */
2026/* Opcode VEX.F2.0F 0x6c - invalid */
2027
2028
2029/* Opcode VEX.0F 0x6d - invalid */
2030
2031/** Opcode VEX.66.0F 0x6d - vpunpckhqdq Vx, Hx, W */
2032FNIEMOP_STUB(iemOp_vpunpckhqdq_Vx_Hx_W);
2033//FNIEMOP_DEF(iemOp_vpunpckhqdq_Vx_Hx_W)
2034//{
2035// IEMOP_MNEMONIC(punpckhqdq, "punpckhqdq");
2036// return FNIEMOP_CALL_1(iemOpCommonSse_HighHigh_To_Full, &g_iemAImpl_punpckhqdq);
2037//}
2038
2039/* Opcode VEX.F3.0F 0x6d - invalid */
2040
2041
2042/* Opcode VEX.0F 0x6e - invalid */
2043
2044FNIEMOP_DEF(iemOp_vmovd_q_Vy_Ey)
2045{
2046 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2047 if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
2048 {
2049 /**
2050 * @opcode 0x6e
2051 * @opcodesub rex.w=1
2052 * @oppfx 0x66
2053 * @opcpuid avx
2054 * @opgroup og_avx_simdint_datamov
2055 * @opxcpttype 5
2056 * @optest 64-bit / op1=1 op2=2 -> op1=2
2057 * @optest 64-bit / op1=0 op2=-42 -> op1=-42
2058 */
2059 IEMOP_MNEMONIC2(VEX_RM, VMOVQ, vmovq, Vq_WO, Eq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OZ_PFX | IEMOPHINT_VEX_L_ZERO);
2060 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2061 {
2062 /* XMM, greg64 */
2063 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2064 IEM_MC_BEGIN(0, 1);
2065 IEM_MC_LOCAL(uint64_t, u64Tmp);
2066
2067 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2068 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2069
2070 IEM_MC_FETCH_GREG_U64(u64Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2071 IEM_MC_STORE_YREG_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
2072
2073 IEM_MC_ADVANCE_RIP();
2074 IEM_MC_END();
2075 }
2076 else
2077 {
2078 /* XMM, [mem64] */
2079 IEM_MC_BEGIN(0, 2);
2080 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2081 IEM_MC_LOCAL(uint64_t, u64Tmp);
2082
2083 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2084 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2085 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2086 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2087
2088 IEM_MC_FETCH_MEM_U64(u64Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2089 IEM_MC_STORE_YREG_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u64Tmp);
2090
2091 IEM_MC_ADVANCE_RIP();
2092 IEM_MC_END();
2093 }
2094 }
2095 else
2096 {
2097 /**
2098 * @opdone
2099 * @opcode 0x6e
2100 * @opcodesub rex.w=0
2101 * @oppfx 0x66
2102 * @opcpuid avx
2103 * @opgroup og_avx_simdint_datamov
2104 * @opxcpttype 5
2105 * @opfunction iemOp_vmovd_q_Vy_Ey
2106 * @optest op1=1 op2=2 -> op1=2
2107 * @optest op1=0 op2=-42 -> op1=-42
2108 */
2109 IEMOP_MNEMONIC2(VEX_RM, VMOVD, vmovd, Vd_WO, Ed, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OZ_PFX | IEMOPHINT_VEX_L_ZERO);
2110 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2111 {
2112 /* XMM, greg32 */
2113 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2114 IEM_MC_BEGIN(0, 1);
2115 IEM_MC_LOCAL(uint32_t, u32Tmp);
2116
2117 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2118 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2119
2120 IEM_MC_FETCH_GREG_U32(u32Tmp, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2121 IEM_MC_STORE_YREG_U32_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
2122
2123 IEM_MC_ADVANCE_RIP();
2124 IEM_MC_END();
2125 }
2126 else
2127 {
2128 /* XMM, [mem32] */
2129 IEM_MC_BEGIN(0, 2);
2130 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2131 IEM_MC_LOCAL(uint32_t, u32Tmp);
2132
2133 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2134 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2135 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2136 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2137
2138 IEM_MC_FETCH_MEM_U32(u32Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2139 IEM_MC_STORE_YREG_U32_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u32Tmp);
2140
2141 IEM_MC_ADVANCE_RIP();
2142 IEM_MC_END();
2143 }
2144 }
2145 return VINF_SUCCESS;
2146}
2147
2148
2149/* Opcode VEX.F3.0F 0x6e - invalid */
2150
2151
2152/* Opcode VEX.0F 0x6f - invalid */
2153
2154/**
2155 * @opcode 0x6f
2156 * @oppfx 0x66
2157 * @opcpuid avx
2158 * @opgroup og_avx_simdint_datamove
2159 * @opxcpttype 1
2160 * @optest op1=1 op2=2 -> op1=2
2161 * @optest op1=0 op2=-42 -> op1=-42
2162 */
2163FNIEMOP_DEF(iemOp_vmovdqa_Vx_Wx)
2164{
2165 IEMOP_MNEMONIC2(VEX_RM, VMOVDQA, vmovdqa, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
2166 Assert(pVCpu->iem.s.uVexLength <= 1);
2167 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2168 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2169 {
2170 /*
2171 * Register, register.
2172 */
2173 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2174 IEM_MC_BEGIN(0, 0);
2175
2176 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2177 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2178 if (pVCpu->iem.s.uVexLength == 0)
2179 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
2180 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2181 else
2182 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
2183 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2184 IEM_MC_ADVANCE_RIP();
2185 IEM_MC_END();
2186 }
2187 else if (pVCpu->iem.s.uVexLength == 0)
2188 {
2189 /*
2190 * Register, memory128.
2191 */
2192 IEM_MC_BEGIN(0, 2);
2193 IEM_MC_LOCAL(RTUINT128U, u128Tmp);
2194 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2195
2196 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2197 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2198 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2199 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2200
2201 IEM_MC_FETCH_MEM_U128_ALIGN_SSE(u128Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2202 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u128Tmp);
2203
2204 IEM_MC_ADVANCE_RIP();
2205 IEM_MC_END();
2206 }
2207 else
2208 {
2209 /*
2210 * Register, memory256.
2211 */
2212 IEM_MC_BEGIN(0, 2);
2213 IEM_MC_LOCAL(RTUINT256U, u256Tmp);
2214 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2215
2216 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2217 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2218 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2219 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2220
2221 IEM_MC_FETCH_MEM_U256_ALIGN_AVX(u256Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2222 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u256Tmp);
2223
2224 IEM_MC_ADVANCE_RIP();
2225 IEM_MC_END();
2226 }
2227 return VINF_SUCCESS;
2228}
2229
2230/**
2231 * @opcode 0x6f
2232 * @oppfx 0xf3
2233 * @opcpuid avx
2234 * @opgroup og_avx_simdint_datamove
2235 * @opxcpttype 4UA
2236 * @optest op1=1 op2=2 -> op1=2
2237 * @optest op1=0 op2=-42 -> op1=-42
2238 */
2239FNIEMOP_DEF(iemOp_vmovdqu_Vx_Wx)
2240{
2241 IEMOP_MNEMONIC2(VEX_RM, VMOVDQU, vmovdqu, Vx_WO, Wx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
2242 Assert(pVCpu->iem.s.uVexLength <= 1);
2243 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2244 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2245 {
2246 /*
2247 * Register, register.
2248 */
2249 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2250 IEM_MC_BEGIN(0, 0);
2251
2252 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2253 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2254 if (pVCpu->iem.s.uVexLength == 0)
2255 IEM_MC_COPY_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
2256 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2257 else
2258 IEM_MC_COPY_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
2259 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2260 IEM_MC_ADVANCE_RIP();
2261 IEM_MC_END();
2262 }
2263 else if (pVCpu->iem.s.uVexLength == 0)
2264 {
2265 /*
2266 * Register, memory128.
2267 */
2268 IEM_MC_BEGIN(0, 2);
2269 IEM_MC_LOCAL(RTUINT128U, u128Tmp);
2270 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2271
2272 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2273 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2274 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2275 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2276
2277 IEM_MC_FETCH_MEM_U128(u128Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2278 IEM_MC_STORE_YREG_U128_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u128Tmp);
2279
2280 IEM_MC_ADVANCE_RIP();
2281 IEM_MC_END();
2282 }
2283 else
2284 {
2285 /*
2286 * Register, memory256.
2287 */
2288 IEM_MC_BEGIN(0, 2);
2289 IEM_MC_LOCAL(RTUINT256U, u256Tmp);
2290 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2291
2292 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2293 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2294 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2295 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2296
2297 IEM_MC_FETCH_MEM_U256(u256Tmp, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2298 IEM_MC_STORE_YREG_U256_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, u256Tmp);
2299
2300 IEM_MC_ADVANCE_RIP();
2301 IEM_MC_END();
2302 }
2303 return VINF_SUCCESS;
2304}
2305
2306
2307/* Opcode VEX.0F 0x70 - invalid */
2308
2309/** Opcode VEX.66.0F 0x70 - vpshufd Vx, Wx, Ib */
2310FNIEMOP_STUB(iemOp_vpshufd_Vx_Wx_Ib);
2311//FNIEMOP_DEF(iemOp_vpshufd_Vx_Wx_Ib)
2312//{
2313// IEMOP_MNEMONIC(vpshufd_Vx_Wx_Ib, "vpshufd Vx,Wx,Ib");
2314// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2315// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2316// {
2317// /*
2318// * Register, register.
2319// */
2320// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2321// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2322//
2323// IEM_MC_BEGIN(3, 0);
2324// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2325// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
2326// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2327// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2328// IEM_MC_PREPARE_SSE_USAGE();
2329// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2330// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2331// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshufd, pDst, pSrc, bEvilArg);
2332// IEM_MC_ADVANCE_RIP();
2333// IEM_MC_END();
2334// }
2335// else
2336// {
2337// /*
2338// * Register, memory.
2339// */
2340// IEM_MC_BEGIN(3, 2);
2341// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2342// IEM_MC_LOCAL(RTUINT128U, uSrc);
2343// IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, pSrc, uSrc, 1);
2344// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2345//
2346// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2347// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2348// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2349// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2350// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2351//
2352// IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2353// IEM_MC_PREPARE_SSE_USAGE();
2354// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2355// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshufd, pDst, pSrc, bEvilArg);
2356//
2357// IEM_MC_ADVANCE_RIP();
2358// IEM_MC_END();
2359// }
2360// return VINF_SUCCESS;
2361//}
2362
2363/** Opcode VEX.F3.0F 0x70 - vpshufhw Vx, Wx, Ib */
2364FNIEMOP_STUB(iemOp_vpshufhw_Vx_Wx_Ib);
2365//FNIEMOP_DEF(iemOp_vpshufhw_Vx_Wx_Ib)
2366//{
2367// IEMOP_MNEMONIC(vpshufhw_Vx_Wx_Ib, "vpshufhw Vx,Wx,Ib");
2368// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2369// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2370// {
2371// /*
2372// * Register, register.
2373// */
2374// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2375// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2376//
2377// IEM_MC_BEGIN(3, 0);
2378// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2379// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
2380// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2381// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2382// IEM_MC_PREPARE_SSE_USAGE();
2383// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2384// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2385// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshufhw, pDst, pSrc, bEvilArg);
2386// IEM_MC_ADVANCE_RIP();
2387// IEM_MC_END();
2388// }
2389// else
2390// {
2391// /*
2392// * Register, memory.
2393// */
2394// IEM_MC_BEGIN(3, 2);
2395// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2396// IEM_MC_LOCAL(RTUINT128U, uSrc);
2397// IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, pSrc, uSrc, 1);
2398// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2399//
2400// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2401// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2402// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2403// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2404// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2405//
2406// IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2407// IEM_MC_PREPARE_SSE_USAGE();
2408// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2409// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshufhw, pDst, pSrc, bEvilArg);
2410//
2411// IEM_MC_ADVANCE_RIP();
2412// IEM_MC_END();
2413// }
2414// return VINF_SUCCESS;
2415//}
2416
2417/** Opcode VEX.F2.0F 0x70 - vpshuflw Vx, Wx, Ib */
2418FNIEMOP_STUB(iemOp_vpshuflw_Vx_Wx_Ib);
2419//FNIEMOP_DEF(iemOp_vpshuflw_Vx_Wx_Ib)
2420//{
2421// IEMOP_MNEMONIC(vpshuflw_Vx_Wx_Ib, "vpshuflw Vx,Wx,Ib");
2422// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2423// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2424// {
2425// /*
2426// * Register, register.
2427// */
2428// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2429// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2430//
2431// IEM_MC_BEGIN(3, 0);
2432// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2433// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
2434// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2435// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2436// IEM_MC_PREPARE_SSE_USAGE();
2437// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2438// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2439// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshuflw, pDst, pSrc, bEvilArg);
2440// IEM_MC_ADVANCE_RIP();
2441// IEM_MC_END();
2442// }
2443// else
2444// {
2445// /*
2446// * Register, memory.
2447// */
2448// IEM_MC_BEGIN(3, 2);
2449// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2450// IEM_MC_LOCAL(RTUINT128U, uSrc);
2451// IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, pSrc, uSrc, 1);
2452// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2453//
2454// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2455// uint8_t bEvil; IEM_OPCODE_GET_NEXT_U8(&bEvil);
2456// IEM_MC_ARG_CONST(uint8_t, bEvilArg, /*=*/ bEvil, 2);
2457// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2458// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2459//
2460// IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2461// IEM_MC_PREPARE_SSE_USAGE();
2462// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2463// IEM_MC_CALL_SSE_AIMPL_3(iemAImpl_pshuflw, pDst, pSrc, bEvilArg);
2464//
2465// IEM_MC_ADVANCE_RIP();
2466// IEM_MC_END();
2467// }
2468// return VINF_SUCCESS;
2469//}
2470
2471
2472/* Opcode VEX.0F 0x71 11/2 - invalid. */
2473/** Opcode VEX.66.0F 0x71 11/2. */
2474FNIEMOP_STUB_1(iemOp_VGrp12_vpsrlw_Hx_Ux_Ib, uint8_t, bRm);
2475
2476/* Opcode VEX.0F 0x71 11/4 - invalid */
2477/** Opcode VEX.66.0F 0x71 11/4. */
2478FNIEMOP_STUB_1(iemOp_VGrp12_vpsraw_Hx_Ux_Ib, uint8_t, bRm);
2479
2480/* Opcode VEX.0F 0x71 11/6 - invalid */
2481/** Opcode VEX.66.0F 0x71 11/6. */
2482FNIEMOP_STUB_1(iemOp_VGrp12_vpsllw_Hx_Ux_Ib, uint8_t, bRm);
2483
2484
2485/**
2486 * VEX Group 12 jump table for register variant.
2487 */
2488IEM_STATIC const PFNIEMOPRM g_apfnVexGroup12RegReg[] =
2489{
2490 /* /0 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2491 /* /1 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2492 /* /2 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp12_vpsrlw_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2493 /* /3 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2494 /* /4 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp12_vpsraw_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2495 /* /5 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2496 /* /6 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp12_vpsllw_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2497 /* /7 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8)
2498};
2499AssertCompile(RT_ELEMENTS(g_apfnVexGroup12RegReg) == 8*4);
2500
2501
2502/** Opcode VEX.0F 0x71. */
2503FNIEMOP_DEF(iemOp_VGrp12)
2504{
2505 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2506 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2507 /* register, register */
2508 return FNIEMOP_CALL_1(g_apfnVexGroup12RegReg[ ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) * 4
2509 + pVCpu->iem.s.idxPrefix], bRm);
2510 return FNIEMOP_CALL_1(iemOp_InvalidWithRMNeedImm8, bRm);
2511}
2512
2513
2514/* Opcode VEX.0F 0x72 11/2 - invalid. */
2515/** Opcode VEX.66.0F 0x72 11/2. */
2516FNIEMOP_STUB_1(iemOp_VGrp13_vpsrld_Hx_Ux_Ib, uint8_t, bRm);
2517
2518/* Opcode VEX.0F 0x72 11/4 - invalid. */
2519/** Opcode VEX.66.0F 0x72 11/4. */
2520FNIEMOP_STUB_1(iemOp_VGrp13_vpsrad_Hx_Ux_Ib, uint8_t, bRm);
2521
2522/* Opcode VEX.0F 0x72 11/6 - invalid. */
2523/** Opcode VEX.66.0F 0x72 11/6. */
2524FNIEMOP_STUB_1(iemOp_VGrp13_vpslld_Hx_Ux_Ib, uint8_t, bRm);
2525
2526
2527/**
2528 * Group 13 jump table for register variant.
2529 */
2530IEM_STATIC const PFNIEMOPRM g_apfnVexGroup13RegReg[] =
2531{
2532 /* /0 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2533 /* /1 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2534 /* /2 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp13_vpsrld_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2535 /* /3 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2536 /* /4 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp13_vpsrad_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2537 /* /5 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2538 /* /6 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp13_vpslld_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2539 /* /7 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8)
2540};
2541AssertCompile(RT_ELEMENTS(g_apfnVexGroup13RegReg) == 8*4);
2542
2543/** Opcode VEX.0F 0x72. */
2544FNIEMOP_DEF(iemOp_VGrp13)
2545{
2546 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2547 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2548 /* register, register */
2549 return FNIEMOP_CALL_1(g_apfnVexGroup13RegReg[ ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) * 4
2550 + pVCpu->iem.s.idxPrefix], bRm);
2551 return FNIEMOP_CALL_1(iemOp_InvalidWithRMNeedImm8, bRm);
2552}
2553
2554
2555/* Opcode VEX.0F 0x73 11/2 - invalid. */
2556/** Opcode VEX.66.0F 0x73 11/2. */
2557FNIEMOP_STUB_1(iemOp_VGrp14_vpsrlq_Hx_Ux_Ib, uint8_t, bRm);
2558
2559/** Opcode VEX.66.0F 0x73 11/3. */
2560FNIEMOP_STUB_1(iemOp_VGrp14_vpsrldq_Hx_Ux_Ib, uint8_t, bRm);
2561
2562/* Opcode VEX.0F 0x73 11/6 - invalid. */
2563/** Opcode VEX.66.0F 0x73 11/6. */
2564FNIEMOP_STUB_1(iemOp_VGrp14_vpsllq_Hx_Ux_Ib, uint8_t, bRm);
2565
2566/** Opcode VEX.66.0F 0x73 11/7. */
2567FNIEMOP_STUB_1(iemOp_VGrp14_vpslldq_Hx_Ux_Ib, uint8_t, bRm);
2568
2569/**
2570 * Group 14 jump table for register variant.
2571 */
2572IEM_STATIC const PFNIEMOPRM g_apfnVexGroup14RegReg[] =
2573{
2574 /* /0 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2575 /* /1 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2576 /* /2 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp14_vpsrlq_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2577 /* /3 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp14_vpsrldq_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2578 /* /4 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2579 /* /5 */ IEMOP_X4(iemOp_InvalidWithRMNeedImm8),
2580 /* /6 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp14_vpsllq_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2581 /* /7 */ iemOp_InvalidWithRMNeedImm8, iemOp_VGrp14_vpslldq_Hx_Ux_Ib, iemOp_InvalidWithRMNeedImm8, iemOp_InvalidWithRMNeedImm8,
2582};
2583AssertCompile(RT_ELEMENTS(g_apfnVexGroup14RegReg) == 8*4);
2584
2585
2586/** Opcode VEX.0F 0x73. */
2587FNIEMOP_DEF(iemOp_VGrp14)
2588{
2589 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2590 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2591 /* register, register */
2592 return FNIEMOP_CALL_1(g_apfnVexGroup14RegReg[ ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) * 4
2593 + pVCpu->iem.s.idxPrefix], bRm);
2594 return FNIEMOP_CALL_1(iemOp_InvalidWithRMNeedImm8, bRm);
2595}
2596
2597
2598///**
2599// * Common worker for SSE2 instructions on the forms:
2600// * pxxx xmm1, xmm2/mem128
2601// *
2602// * Proper alignment of the 128-bit operand is enforced.
2603// * Exceptions type 4. SSE2 cpuid checks.
2604// */
2605//FNIEMOP_DEF_1(iemOpCommonSse2_FullFull_To_Full, PCIEMOPMEDIAF2, pImpl)
2606//{
2607// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2608// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2609// {
2610// /*
2611// * Register, register.
2612// */
2613// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2614// IEM_MC_BEGIN(2, 0);
2615// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2616// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
2617// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2618// IEM_MC_PREPARE_SSE_USAGE();
2619// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2620// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2621// IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
2622// IEM_MC_ADVANCE_RIP();
2623// IEM_MC_END();
2624// }
2625// else
2626// {
2627// /*
2628// * Register, memory.
2629// */
2630// IEM_MC_BEGIN(2, 2);
2631// IEM_MC_ARG(PRTUINT128U, pDst, 0);
2632// IEM_MC_LOCAL(RTUINT128U, uSrc);
2633// IEM_MC_ARG_LOCAL_REF(PCRTUINT128U, pSrc, uSrc, 1);
2634// IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2635//
2636// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2637// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
2638// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
2639// IEM_MC_FETCH_MEM_U128_ALIGN_SSE(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2640//
2641// IEM_MC_PREPARE_SSE_USAGE();
2642// IEM_MC_REF_XREG_U128(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2643// IEM_MC_CALL_SSE_AIMPL_2(pImpl->pfnU128, pDst, pSrc);
2644//
2645// IEM_MC_ADVANCE_RIP();
2646// IEM_MC_END();
2647// }
2648// return VINF_SUCCESS;
2649//}
2650
2651
2652/* Opcode VEX.0F 0x74 - invalid */
2653
2654/** Opcode VEX.66.0F 0x74 - vpcmpeqb Vx, Hx, Wx */
2655FNIEMOP_STUB(iemOp_vpcmpeqb_Vx_Hx_Wx);
2656//FNIEMOP_DEF(iemOp_vpcmpeqb_Vx_Hx_Wx)
2657//{
2658// IEMOP_MNEMONIC(vpcmpeqb, "vpcmpeqb");
2659// return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pcmpeqb);
2660//}
2661
2662/* Opcode VEX.F3.0F 0x74 - invalid */
2663/* Opcode VEX.F2.0F 0x74 - invalid */
2664
2665
2666/* Opcode VEX.0F 0x75 - invalid */
2667
2668/** Opcode VEX.66.0F 0x75 - vpcmpeqw Vx, Hx, Wx */
2669FNIEMOP_STUB(iemOp_vpcmpeqw_Vx_Hx_Wx);
2670//FNIEMOP_DEF(iemOp_vpcmpeqw_Vx_Hx_Wx)
2671//{
2672// IEMOP_MNEMONIC(vpcmpeqw, "vpcmpeqw");
2673// return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pcmpeqw);
2674//}
2675
2676/* Opcode VEX.F3.0F 0x75 - invalid */
2677/* Opcode VEX.F2.0F 0x75 - invalid */
2678
2679
2680/* Opcode VEX.0F 0x76 - invalid */
2681
2682/** Opcode VEX.66.0F 0x76 - vpcmpeqd Vx, Hx, Wx */
2683FNIEMOP_STUB(iemOp_vpcmpeqd_Vx_Hx_Wx);
2684//FNIEMOP_DEF(iemOp_vpcmpeqd_Vx_Hx_Wx)
2685//{
2686// IEMOP_MNEMONIC(vpcmpeqd, "vpcmpeqd");
2687// return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pcmpeqd);
2688//}
2689
2690/* Opcode VEX.F3.0F 0x76 - invalid */
2691/* Opcode VEX.F2.0F 0x76 - invalid */
2692
2693
2694/** Opcode VEX.0F 0x77 - vzeroupperv vzeroallv */
2695FNIEMOP_STUB(iemOp_vzeroupperv__vzeroallv);
2696/* Opcode VEX.66.0F 0x77 - invalid */
2697/* Opcode VEX.F3.0F 0x77 - invalid */
2698/* Opcode VEX.F2.0F 0x77 - invalid */
2699
2700/* Opcode VEX.0F 0x78 - invalid */
2701/* Opcode VEX.66.0F 0x78 - invalid */
2702/* Opcode VEX.F3.0F 0x78 - invalid */
2703/* Opcode VEX.F2.0F 0x78 - invalid */
2704
2705/* Opcode VEX.0F 0x79 - invalid */
2706/* Opcode VEX.66.0F 0x79 - invalid */
2707/* Opcode VEX.F3.0F 0x79 - invalid */
2708/* Opcode VEX.F2.0F 0x79 - invalid */
2709
2710/* Opcode VEX.0F 0x7a - invalid */
2711/* Opcode VEX.66.0F 0x7a - invalid */
2712/* Opcode VEX.F3.0F 0x7a - invalid */
2713/* Opcode VEX.F2.0F 0x7a - invalid */
2714
2715/* Opcode VEX.0F 0x7b - invalid */
2716/* Opcode VEX.66.0F 0x7b - invalid */
2717/* Opcode VEX.F3.0F 0x7b - invalid */
2718/* Opcode VEX.F2.0F 0x7b - invalid */
2719
2720/* Opcode VEX.0F 0x7c - invalid */
2721/** Opcode VEX.66.0F 0x7c - vhaddpd Vpd, Hpd, Wpd */
2722FNIEMOP_STUB(iemOp_vhaddpd_Vpd_Hpd_Wpd);
2723/* Opcode VEX.F3.0F 0x7c - invalid */
2724/** Opcode VEX.F2.0F 0x7c - vhaddps Vps, Hps, Wps */
2725FNIEMOP_STUB(iemOp_vhaddps_Vps_Hps_Wps);
2726
2727/* Opcode VEX.0F 0x7d - invalid */
2728/** Opcode VEX.66.0F 0x7d - vhsubpd Vpd, Hpd, Wpd */
2729FNIEMOP_STUB(iemOp_vhsubpd_Vpd_Hpd_Wpd);
2730/* Opcode VEX.F3.0F 0x7d - invalid */
2731/** Opcode VEX.F2.0F 0x7d - vhsubps Vps, Hps, Wps */
2732FNIEMOP_STUB(iemOp_vhsubps_Vps_Hps_Wps);
2733
2734
2735/* Opcode VEX.0F 0x7e - invalid */
2736
2737FNIEMOP_DEF(iemOp_vmovd_q_Ey_Vy)
2738{
2739 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2740 if (pVCpu->iem.s.fPrefixes & IEM_OP_PRF_SIZE_REX_W)
2741 {
2742 /**
2743 * @opcode 0x7e
2744 * @opcodesub rex.w=1
2745 * @oppfx 0x66
2746 * @opcpuid avx
2747 * @opgroup og_avx_simdint_datamov
2748 * @opxcpttype 5
2749 * @optest 64-bit / op1=1 op2=2 -> op1=2
2750 * @optest 64-bit / op1=0 op2=-42 -> op1=-42
2751 */
2752 IEMOP_MNEMONIC2(VEX_MR, VMOVQ, vmovq, Eq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OZ_PFX | IEMOPHINT_VEX_L_ZERO);
2753 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2754 {
2755 /* greg64, XMM */
2756 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2757 IEM_MC_BEGIN(0, 1);
2758 IEM_MC_LOCAL(uint64_t, u64Tmp);
2759
2760 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2761 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2762
2763 IEM_MC_FETCH_YREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2764 IEM_MC_STORE_GREG_U64((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u64Tmp);
2765
2766 IEM_MC_ADVANCE_RIP();
2767 IEM_MC_END();
2768 }
2769 else
2770 {
2771 /* [mem64], XMM */
2772 IEM_MC_BEGIN(0, 2);
2773 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2774 IEM_MC_LOCAL(uint64_t, u64Tmp);
2775
2776 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2777 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2778 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2779 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2780
2781 IEM_MC_FETCH_YREG_U64(u64Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2782 IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u64Tmp);
2783
2784 IEM_MC_ADVANCE_RIP();
2785 IEM_MC_END();
2786 }
2787 }
2788 else
2789 {
2790 /**
2791 * @opdone
2792 * @opcode 0x7e
2793 * @opcodesub rex.w=0
2794 * @oppfx 0x66
2795 * @opcpuid avx
2796 * @opgroup og_avx_simdint_datamov
2797 * @opxcpttype 5
2798 * @opfunction iemOp_vmovd_q_Vy_Ey
2799 * @optest op1=1 op2=2 -> op1=2
2800 * @optest op1=0 op2=-42 -> op1=-42
2801 */
2802 IEMOP_MNEMONIC2(VEX_MR, VMOVD, vmovd, Ed_WO, Vd, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OZ_PFX | IEMOPHINT_VEX_L_ZERO);
2803 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2804 {
2805 /* greg32, XMM */
2806 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2807 IEM_MC_BEGIN(0, 1);
2808 IEM_MC_LOCAL(uint32_t, u32Tmp);
2809
2810 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2811 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2812
2813 IEM_MC_FETCH_YREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2814 IEM_MC_STORE_GREG_U32((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB, u32Tmp);
2815
2816 IEM_MC_ADVANCE_RIP();
2817 IEM_MC_END();
2818 }
2819 else
2820 {
2821 /* [mem32], XMM */
2822 IEM_MC_BEGIN(0, 2);
2823 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2824 IEM_MC_LOCAL(uint32_t, u32Tmp);
2825
2826 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2827 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2828 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2829 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2830
2831 IEM_MC_FETCH_YREG_U32(u32Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2832 IEM_MC_STORE_MEM_U32(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u32Tmp);
2833
2834 IEM_MC_ADVANCE_RIP();
2835 IEM_MC_END();
2836 }
2837 }
2838 return VINF_SUCCESS;
2839}
2840
2841/**
2842 * @opcode 0x7e
2843 * @oppfx 0xf3
2844 * @opcpuid avx
2845 * @opgroup og_avx_pcksclr_datamove
2846 * @opxcpttype none
2847 * @optest op1=1 op2=2 -> op1=2
2848 * @optest op1=0 op2=-42 -> op1=-42
2849 */
2850FNIEMOP_DEF(iemOp_vmovq_Vq_Wq)
2851{
2852 IEMOP_MNEMONIC2(VEX_RM, VMOVQ, vmovq, Vq_WO, Wq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
2853 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2854 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2855 {
2856 /*
2857 * Register, register.
2858 */
2859 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2860 IEM_MC_BEGIN(0, 0);
2861
2862 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2863 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2864
2865 IEM_MC_COPY_YREG_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg,
2866 (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
2867 IEM_MC_ADVANCE_RIP();
2868 IEM_MC_END();
2869 }
2870 else
2871 {
2872 /*
2873 * Memory, register.
2874 */
2875 IEM_MC_BEGIN(0, 2);
2876 IEM_MC_LOCAL(uint64_t, uSrc);
2877 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2878
2879 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2880 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
2881 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2882 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2883
2884 IEM_MC_FETCH_MEM_U64(uSrc, pVCpu->iem.s.iEffSeg, GCPtrEffSrc);
2885 IEM_MC_STORE_YREG_U64_ZX_VLMAX(((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg, uSrc);
2886
2887 IEM_MC_ADVANCE_RIP();
2888 IEM_MC_END();
2889 }
2890 return VINF_SUCCESS;
2891
2892}
2893/* Opcode VEX.F2.0F 0x7e - invalid */
2894
2895
2896/* Opcode VEX.0F 0x7f - invalid */
2897
2898/**
2899 * @opcode 0x7f
2900 * @oppfx 0x66
2901 * @opcpuid avx
2902 * @opgroup og_avx_simdint_datamove
2903 * @opxcpttype 1
2904 * @optest op1=1 op2=2 -> op1=2
2905 * @optest op1=0 op2=-42 -> op1=-42
2906 */
2907FNIEMOP_DEF(iemOp_vmovdqa_Wx_Vx)
2908{
2909 IEMOP_MNEMONIC2(VEX_MR, VMOVDQA, vmovdqa, Wx_WO, Vx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
2910 Assert(pVCpu->iem.s.uVexLength <= 1);
2911 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2912 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2913 {
2914 /*
2915 * Register, register.
2916 */
2917 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2918 IEM_MC_BEGIN(0, 0);
2919
2920 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2921 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2922 if (pVCpu->iem.s.uVexLength == 0)
2923 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
2924 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2925 else
2926 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
2927 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2928 IEM_MC_ADVANCE_RIP();
2929 IEM_MC_END();
2930 }
2931 else if (pVCpu->iem.s.uVexLength == 0)
2932 {
2933 /*
2934 * Register, memory128.
2935 */
2936 IEM_MC_BEGIN(0, 2);
2937 IEM_MC_LOCAL(RTUINT128U, u128Tmp);
2938 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2939
2940 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2941 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2942 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2943 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2944
2945 IEM_MC_FETCH_YREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2946 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u128Tmp);
2947
2948 IEM_MC_ADVANCE_RIP();
2949 IEM_MC_END();
2950 }
2951 else
2952 {
2953 /*
2954 * Register, memory256.
2955 */
2956 IEM_MC_BEGIN(0, 2);
2957 IEM_MC_LOCAL(RTUINT256U, u256Tmp);
2958 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
2959
2960 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
2961 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2962 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2963 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
2964
2965 IEM_MC_FETCH_YREG_U256(u256Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
2966 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u256Tmp);
2967
2968 IEM_MC_ADVANCE_RIP();
2969 IEM_MC_END();
2970 }
2971 return VINF_SUCCESS;
2972}
2973
2974/**
2975 * @opcode 0x7f
2976 * @oppfx 0xf3
2977 * @opcpuid avx
2978 * @opgroup og_avx_simdint_datamove
2979 * @opxcpttype 4UA
2980 * @optest op1=1 op2=2 -> op1=2
2981 * @optest op1=0 op2=-42 -> op1=-42
2982 */
2983FNIEMOP_DEF(iemOp_vmovdqu_Wx_Vx)
2984{
2985 IEMOP_MNEMONIC2(VEX_MR, VMOVDQU, vmovdqu, Wx_WO, Vx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
2986 Assert(pVCpu->iem.s.uVexLength <= 1);
2987 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
2988 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
2989 {
2990 /*
2991 * Register, register.
2992 */
2993 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
2994 IEM_MC_BEGIN(0, 0);
2995
2996 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
2997 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
2998 if (pVCpu->iem.s.uVexLength == 0)
2999 IEM_MC_COPY_YREG_U128_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
3000 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3001 else
3002 IEM_MC_COPY_YREG_U256_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
3003 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3004 IEM_MC_ADVANCE_RIP();
3005 IEM_MC_END();
3006 }
3007 else if (pVCpu->iem.s.uVexLength == 0)
3008 {
3009 /*
3010 * Register, memory128.
3011 */
3012 IEM_MC_BEGIN(0, 2);
3013 IEM_MC_LOCAL(RTUINT128U, u128Tmp);
3014 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
3015
3016 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
3017 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
3018 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3019 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
3020
3021 IEM_MC_FETCH_YREG_U128(u128Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3022 IEM_MC_STORE_MEM_U128(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u128Tmp);
3023
3024 IEM_MC_ADVANCE_RIP();
3025 IEM_MC_END();
3026 }
3027 else
3028 {
3029 /*
3030 * Register, memory256.
3031 */
3032 IEM_MC_BEGIN(0, 2);
3033 IEM_MC_LOCAL(RTUINT256U, u256Tmp);
3034 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
3035
3036 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
3037 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
3038 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3039 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
3040
3041 IEM_MC_FETCH_YREG_U256(u256Tmp, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3042 IEM_MC_STORE_MEM_U256(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, u256Tmp);
3043
3044 IEM_MC_ADVANCE_RIP();
3045 IEM_MC_END();
3046 }
3047 return VINF_SUCCESS;
3048}
3049
3050/* Opcode VEX.F2.0F 0x7f - invalid */
3051
3052
3053/* Opcode VEX.0F 0x80 - invalid */
3054/* Opcode VEX.0F 0x81 - invalid */
3055/* Opcode VEX.0F 0x82 - invalid */
3056/* Opcode VEX.0F 0x83 - invalid */
3057/* Opcode VEX.0F 0x84 - invalid */
3058/* Opcode VEX.0F 0x85 - invalid */
3059/* Opcode VEX.0F 0x86 - invalid */
3060/* Opcode VEX.0F 0x87 - invalid */
3061/* Opcode VEX.0F 0x88 - invalid */
3062/* Opcode VEX.0F 0x89 - invalid */
3063/* Opcode VEX.0F 0x8a - invalid */
3064/* Opcode VEX.0F 0x8b - invalid */
3065/* Opcode VEX.0F 0x8c - invalid */
3066/* Opcode VEX.0F 0x8d - invalid */
3067/* Opcode VEX.0F 0x8e - invalid */
3068/* Opcode VEX.0F 0x8f - invalid */
3069/* Opcode VEX.0F 0x90 - invalid */
3070/* Opcode VEX.0F 0x91 - invalid */
3071/* Opcode VEX.0F 0x92 - invalid */
3072/* Opcode VEX.0F 0x93 - invalid */
3073/* Opcode VEX.0F 0x94 - invalid */
3074/* Opcode VEX.0F 0x95 - invalid */
3075/* Opcode VEX.0F 0x96 - invalid */
3076/* Opcode VEX.0F 0x97 - invalid */
3077/* Opcode VEX.0F 0x98 - invalid */
3078/* Opcode VEX.0F 0x99 - invalid */
3079/* Opcode VEX.0F 0x9a - invalid */
3080/* Opcode VEX.0F 0x9b - invalid */
3081/* Opcode VEX.0F 0x9c - invalid */
3082/* Opcode VEX.0F 0x9d - invalid */
3083/* Opcode VEX.0F 0x9e - invalid */
3084/* Opcode VEX.0F 0x9f - invalid */
3085/* Opcode VEX.0F 0xa0 - invalid */
3086/* Opcode VEX.0F 0xa1 - invalid */
3087/* Opcode VEX.0F 0xa2 - invalid */
3088/* Opcode VEX.0F 0xa3 - invalid */
3089/* Opcode VEX.0F 0xa4 - invalid */
3090/* Opcode VEX.0F 0xa5 - invalid */
3091/* Opcode VEX.0F 0xa6 - invalid */
3092/* Opcode VEX.0F 0xa7 - invalid */
3093/* Opcode VEX.0F 0xa8 - invalid */
3094/* Opcode VEX.0F 0xa9 - invalid */
3095/* Opcode VEX.0F 0xaa - invalid */
3096/* Opcode VEX.0F 0xab - invalid */
3097/* Opcode VEX.0F 0xac - invalid */
3098/* Opcode VEX.0F 0xad - invalid */
3099
3100
3101/* Opcode VEX.0F 0xae mem/0 - invalid. */
3102/* Opcode VEX.0F 0xae mem/1 - invalid. */
3103
3104/**
3105 * @ opmaps grp15
3106 * @ opcode !11/2
3107 * @ oppfx none
3108 * @ opcpuid sse
3109 * @ opgroup og_sse_mxcsrsm
3110 * @ opxcpttype 5
3111 * @ optest op1=0 -> mxcsr=0
3112 * @ optest op1=0x2083 -> mxcsr=0x2083
3113 * @ optest op1=0xfffffffe -> value.xcpt=0xd
3114 * @ optest op1=0x2083 cr0|=ts -> value.xcpt=0x7
3115 * @ optest op1=0x2083 cr0|=em -> value.xcpt=0x6
3116 * @ optest op1=0x2083 cr0|=mp -> mxcsr=0x2083
3117 * @ optest op1=0x2083 cr4&~=osfxsr -> value.xcpt=0x6
3118 * @ optest op1=0x2083 cr0|=ts,em -> value.xcpt=0x6
3119 * @ optest op1=0x2083 cr0|=em cr4&~=osfxsr -> value.xcpt=0x6
3120 * @ optest op1=0x2083 cr0|=ts,em cr4&~=osfxsr -> value.xcpt=0x6
3121 * @ optest op1=0x2083 cr0|=ts,em,mp cr4&~=osfxsr -> value.xcpt=0x6
3122 */
3123FNIEMOP_STUB_1(iemOp_VGrp15_vldmxcsr, uint8_t, bRm);
3124//FNIEMOP_DEF_1(iemOp_VGrp15_vldmxcsr, uint8_t, bRm)
3125//{
3126// IEMOP_MNEMONIC1(M_MEM, VLDMXCSR, vldmxcsr, MdRO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
3127// if (!IEM_GET_GUEST_CPU_FEATURES(pVCpu)->fSse)
3128// return IEMOP_RAISE_INVALID_OPCODE();
3129//
3130// IEM_MC_BEGIN(2, 0);
3131// IEM_MC_ARG(uint8_t, iEffSeg, 0);
3132// IEM_MC_ARG(RTGCPTR, GCPtrEff, 1);
3133// IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
3134// IEMOP_HLP_DONE_DECODING_NO_LOCK_PREFIX();
3135// IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
3136// IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
3137// IEM_MC_CALL_CIMPL_2(iemCImpl_ldmxcsr, iEffSeg, GCPtrEff);
3138// IEM_MC_END();
3139// return VINF_SUCCESS;
3140//}
3141
3142
3143/**
3144 * @opmaps vexgrp15
3145 * @opcode !11/3
3146 * @oppfx none
3147 * @opcpuid avx
3148 * @opgroup og_avx_mxcsrsm
3149 * @opxcpttype 5
3150 * @optest mxcsr=0 -> op1=0
3151 * @optest mxcsr=0x2083 -> op1=0x2083
3152 * @optest mxcsr=0x2084 cr0|=ts -> value.xcpt=0x7
3153 * @optest !amd / mxcsr=0x2085 cr0|=em -> op1=0x2085
3154 * @optest amd / mxcsr=0x2085 cr0|=em -> value.xcpt=0x6
3155 * @optest mxcsr=0x2086 cr0|=mp -> op1=0x2086
3156 * @optest mxcsr=0x2087 cr4&~=osfxsr -> op1=0x2087
3157 * @optest mxcsr=0x208f cr4&~=osxsave -> value.xcpt=0x6
3158 * @optest mxcsr=0x2087 cr4&~=osfxsr,osxsave -> value.xcpt=0x6
3159 * @optest !amd / mxcsr=0x2088 cr0|=ts,em -> value.xcpt=0x7
3160 * @optest amd / mxcsr=0x2088 cr0|=ts,em -> value.xcpt=0x6
3161 * @optest !amd / mxcsr=0x2089 cr0|=em cr4&~=osfxsr -> op1=0x2089
3162 * @optest amd / mxcsr=0x2089 cr0|=em cr4&~=osfxsr -> value.xcpt=0x6
3163 * @optest !amd / mxcsr=0x208a cr0|=ts,em cr4&~=osfxsr -> value.xcpt=0x7
3164 * @optest amd / mxcsr=0x208a cr0|=ts,em cr4&~=osfxsr -> value.xcpt=0x6
3165 * @optest !amd / mxcsr=0x208b cr0|=ts,em,mp cr4&~=osfxsr -> value.xcpt=0x7
3166 * @optest amd / mxcsr=0x208b cr0|=ts,em,mp cr4&~=osfxsr -> value.xcpt=0x6
3167 * @optest !amd / mxcsr=0x208c xcr0&~=all_avx -> value.xcpt=0x6
3168 * @optest amd / mxcsr=0x208c xcr0&~=all_avx -> op1=0x208c
3169 * @optest !amd / mxcsr=0x208d xcr0&~=all_avx_sse -> value.xcpt=0x6
3170 * @optest amd / mxcsr=0x208d xcr0&~=all_avx_sse -> op1=0x208d
3171 * @optest !amd / mxcsr=0x208e xcr0&~=all_avx cr0|=ts -> value.xcpt=0x6
3172 * @optest amd / mxcsr=0x208e xcr0&~=all_avx cr0|=ts -> value.xcpt=0x7
3173 * @optest mxcsr=0x2082 cr0|=ts cr4&~=osxsave -> value.xcpt=0x6
3174 * @optest mxcsr=0x2081 xcr0&~=all_avx cr0|=ts cr4&~=osxsave
3175 * -> value.xcpt=0x6
3176 * @remarks AMD Jaguar CPU (f0x16,m0,s1) \#UD when CR0.EM is set. It also
3177 * doesn't seem to check XCR0[2:1] != 11b. This does not match the
3178 * APMv4 rev 3.17 page 509.
3179 * @todo Test this instruction on AMD Ryzen.
3180 */
3181FNIEMOP_DEF_1(iemOp_VGrp15_vstmxcsr, uint8_t, bRm)
3182{
3183 IEMOP_MNEMONIC1(VEX_M_MEM, VSTMXCSR, vstmxcsr, Md_WO, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
3184 IEM_MC_BEGIN(2, 0);
3185 IEM_MC_ARG(uint8_t, iEffSeg, 0);
3186 IEM_MC_ARG(RTGCPTR, GCPtrEff, 1);
3187 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEff, bRm, 0);
3188 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
3189 IEM_MC_ACTUALIZE_SSE_STATE_FOR_READ();
3190 IEM_MC_ASSIGN(iEffSeg, pVCpu->iem.s.iEffSeg);
3191 IEM_MC_CALL_CIMPL_2(iemCImpl_vstmxcsr, iEffSeg, GCPtrEff);
3192 IEM_MC_END();
3193 return VINF_SUCCESS;
3194}
3195
3196/* Opcode VEX.0F 0xae mem/4 - invalid. */
3197/* Opcode VEX.0F 0xae mem/5 - invalid. */
3198/* Opcode VEX.0F 0xae mem/6 - invalid. */
3199/* Opcode VEX.0F 0xae mem/7 - invalid. */
3200
3201/* Opcode VEX.0F 0xae 11b/0 - invalid. */
3202/* Opcode VEX.0F 0xae 11b/1 - invalid. */
3203/* Opcode VEX.0F 0xae 11b/2 - invalid. */
3204/* Opcode VEX.0F 0xae 11b/3 - invalid. */
3205/* Opcode VEX.0F 0xae 11b/4 - invalid. */
3206/* Opcode VEX.0F 0xae 11b/5 - invalid. */
3207/* Opcode VEX.0F 0xae 11b/6 - invalid. */
3208/* Opcode VEX.0F 0xae 11b/7 - invalid. */
3209
3210/**
3211 * Vex group 15 jump table for memory variant.
3212 */
3213IEM_STATIC const PFNIEMOPRM g_apfnVexGroup15MemReg[] =
3214{ /* pfx: none, 066h, 0f3h, 0f2h */
3215 /* /0 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3216 /* /1 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3217 /* /2 */ iemOp_VGrp15_vldmxcsr, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3218 /* /3 */ iemOp_VGrp15_vstmxcsr, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3219 /* /4 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3220 /* /5 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3221 /* /6 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3222 /* /7 */ iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM, iemOp_InvalidWithRM,
3223};
3224AssertCompile(RT_ELEMENTS(g_apfnVexGroup15MemReg) == 8*4);
3225
3226
3227/** Opcode vex. 0xae. */
3228FNIEMOP_DEF(iemOp_VGrp15)
3229{
3230 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
3231 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
3232 /* register, register */
3233 return FNIEMOP_CALL_1(iemOp_InvalidWithRM, bRm);
3234
3235 /* memory, register */
3236 return FNIEMOP_CALL_1(g_apfnVexGroup15MemReg[ ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) * 4
3237 + pVCpu->iem.s.idxPrefix], bRm);
3238}
3239
3240
3241/* Opcode VEX.0F 0xaf - invalid. */
3242
3243/* Opcode VEX.0F 0xb0 - invalid. */
3244/* Opcode VEX.0F 0xb1 - invalid. */
3245/* Opcode VEX.0F 0xb2 - invalid. */
3246/* Opcode VEX.0F 0xb2 - invalid. */
3247/* Opcode VEX.0F 0xb3 - invalid. */
3248/* Opcode VEX.0F 0xb4 - invalid. */
3249/* Opcode VEX.0F 0xb5 - invalid. */
3250/* Opcode VEX.0F 0xb6 - invalid. */
3251/* Opcode VEX.0F 0xb7 - invalid. */
3252/* Opcode VEX.0F 0xb8 - invalid. */
3253/* Opcode VEX.0F 0xb9 - invalid. */
3254/* Opcode VEX.0F 0xba - invalid. */
3255/* Opcode VEX.0F 0xbb - invalid. */
3256/* Opcode VEX.0F 0xbc - invalid. */
3257/* Opcode VEX.0F 0xbd - invalid. */
3258/* Opcode VEX.0F 0xbe - invalid. */
3259/* Opcode VEX.0F 0xbf - invalid. */
3260
3261/* Opcode VEX.0F 0xc0 - invalid. */
3262/* Opcode VEX.66.0F 0xc0 - invalid. */
3263/* Opcode VEX.F3.0F 0xc0 - invalid. */
3264/* Opcode VEX.F2.0F 0xc0 - invalid. */
3265
3266/* Opcode VEX.0F 0xc1 - invalid. */
3267/* Opcode VEX.66.0F 0xc1 - invalid. */
3268/* Opcode VEX.F3.0F 0xc1 - invalid. */
3269/* Opcode VEX.F2.0F 0xc1 - invalid. */
3270
3271/** Opcode VEX.0F 0xc2 - vcmpps Vps,Hps,Wps,Ib */
3272FNIEMOP_STUB(iemOp_vcmpps_Vps_Hps_Wps_Ib);
3273/** Opcode VEX.66.0F 0xc2 - vcmppd Vpd,Hpd,Wpd,Ib */
3274FNIEMOP_STUB(iemOp_vcmppd_Vpd_Hpd_Wpd_Ib);
3275/** Opcode VEX.F3.0F 0xc2 - vcmpss Vss,Hss,Wss,Ib */
3276FNIEMOP_STUB(iemOp_vcmpss_Vss_Hss_Wss_Ib);
3277/** Opcode VEX.F2.0F 0xc2 - vcmpsd Vsd,Hsd,Wsd,Ib */
3278FNIEMOP_STUB(iemOp_vcmpsd_Vsd_Hsd_Wsd_Ib);
3279
3280/* Opcode VEX.0F 0xc3 - invalid */
3281/* Opcode VEX.66.0F 0xc3 - invalid */
3282/* Opcode VEX.F3.0F 0xc3 - invalid */
3283/* Opcode VEX.F2.0F 0xc3 - invalid */
3284
3285/* Opcode VEX.0F 0xc4 - invalid */
3286/** Opcode VEX.66.0F 0xc4 - vpinsrw Vdq,Hdq,Ry/Mw,Ib */
3287FNIEMOP_STUB(iemOp_vpinsrw_Vdq_Hdq_RyMw_Ib);
3288/* Opcode VEX.F3.0F 0xc4 - invalid */
3289/* Opcode VEX.F2.0F 0xc4 - invalid */
3290
3291/* Opcode VEX.0F 0xc5 - invlid */
3292/** Opcode VEX.66.0F 0xc5 - vpextrw Gd, Udq, Ib */
3293FNIEMOP_STUB(iemOp_vpextrw_Gd_Udq_Ib);
3294/* Opcode VEX.F3.0F 0xc5 - invalid */
3295/* Opcode VEX.F2.0F 0xc5 - invalid */
3296
3297/** Opcode VEX.0F 0xc6 - vshufps Vps,Hps,Wps,Ib */
3298FNIEMOP_STUB(iemOp_vshufps_Vps_Hps_Wps_Ib);
3299/** Opcode VEX.66.0F 0xc6 - vshufpd Vpd,Hpd,Wpd,Ib */
3300FNIEMOP_STUB(iemOp_vshufpd_Vpd_Hpd_Wpd_Ib);
3301/* Opcode VEX.F3.0F 0xc6 - invalid */
3302/* Opcode VEX.F2.0F 0xc6 - invalid */
3303
3304/* Opcode VEX.0F 0xc7 - invalid */
3305/* Opcode VEX.66.0F 0xc7 - invalid */
3306/* Opcode VEX.F3.0F 0xc7 - invalid */
3307/* Opcode VEX.F2.0F 0xc7 - invalid */
3308
3309/* Opcode VEX.0F 0xc8 - invalid */
3310/* Opcode VEX.0F 0xc9 - invalid */
3311/* Opcode VEX.0F 0xca - invalid */
3312/* Opcode VEX.0F 0xcb - invalid */
3313/* Opcode VEX.0F 0xcc - invalid */
3314/* Opcode VEX.0F 0xcd - invalid */
3315/* Opcode VEX.0F 0xce - invalid */
3316/* Opcode VEX.0F 0xcf - invalid */
3317
3318
3319/* Opcode VEX.0F 0xd0 - invalid */
3320/** Opcode VEX.66.0F 0xd0 - vaddsubpd Vpd, Hpd, Wpd */
3321FNIEMOP_STUB(iemOp_vaddsubpd_Vpd_Hpd_Wpd);
3322/* Opcode VEX.F3.0F 0xd0 - invalid */
3323/** Opcode VEX.F2.0F 0xd0 - vaddsubps Vps, Hps, Wps */
3324FNIEMOP_STUB(iemOp_vaddsubps_Vps_Hps_Wps);
3325
3326/* Opcode VEX.0F 0xd1 - invalid */
3327/** Opcode VEX.66.0F 0xd1 - vpsrlw Vx, Hx, W */
3328FNIEMOP_STUB(iemOp_vpsrlw_Vx_Hx_W);
3329/* Opcode VEX.F3.0F 0xd1 - invalid */
3330/* Opcode VEX.F2.0F 0xd1 - invalid */
3331
3332/* Opcode VEX.0F 0xd2 - invalid */
3333/** Opcode VEX.66.0F 0xd2 - vpsrld Vx, Hx, Wx */
3334FNIEMOP_STUB(iemOp_vpsrld_Vx_Hx_Wx);
3335/* Opcode VEX.F3.0F 0xd2 - invalid */
3336/* Opcode VEX.F2.0F 0xd2 - invalid */
3337
3338/* Opcode VEX.0F 0xd3 - invalid */
3339/** Opcode VEX.66.0F 0xd3 - vpsrlq Vx, Hx, Wx */
3340FNIEMOP_STUB(iemOp_vpsrlq_Vx_Hx_Wx);
3341/* Opcode VEX.F3.0F 0xd3 - invalid */
3342/* Opcode VEX.F2.0F 0xd3 - invalid */
3343
3344/* Opcode VEX.0F 0xd4 - invalid */
3345/** Opcode VEX.66.0F 0xd4 - vpaddq Vx, Hx, W */
3346FNIEMOP_STUB(iemOp_vpaddq_Vx_Hx_W);
3347/* Opcode VEX.F3.0F 0xd4 - invalid */
3348/* Opcode VEX.F2.0F 0xd4 - invalid */
3349
3350/* Opcode VEX.0F 0xd5 - invalid */
3351/** Opcode VEX.66.0F 0xd5 - vpmullw Vx, Hx, Wx */
3352FNIEMOP_STUB(iemOp_vpmullw_Vx_Hx_Wx);
3353/* Opcode VEX.F3.0F 0xd5 - invalid */
3354/* Opcode VEX.F2.0F 0xd5 - invalid */
3355
3356/* Opcode VEX.0F 0xd6 - invalid */
3357
3358/**
3359 * @opcode 0xd6
3360 * @oppfx 0x66
3361 * @opcpuid avx
3362 * @opgroup og_avx_pcksclr_datamove
3363 * @opxcpttype none
3364 * @optest op1=-1 op2=2 -> op1=2
3365 * @optest op1=0 op2=-42 -> op1=-42
3366 */
3367FNIEMOP_DEF(iemOp_vmovq_Wq_Vq)
3368{
3369 IEMOP_MNEMONIC2(VEX_MR, VMOVQ, vmovq, Wq_WO, Vq, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES | IEMOPHINT_VEX_L_ZERO);
3370 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
3371 if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT))
3372 {
3373 /*
3374 * Register, register.
3375 */
3376 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
3377 IEM_MC_BEGIN(0, 0);
3378
3379 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3380 IEM_MC_ACTUALIZE_AVX_STATE_FOR_CHANGE();
3381
3382 IEM_MC_COPY_YREG_U64_ZX_VLMAX((bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB,
3383 ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3384 IEM_MC_ADVANCE_RIP();
3385 IEM_MC_END();
3386 }
3387 else
3388 {
3389 /*
3390 * Memory, register.
3391 */
3392 IEM_MC_BEGIN(0, 2);
3393 IEM_MC_LOCAL(uint64_t, uSrc);
3394 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
3395
3396 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
3397 IEMOP_HLP_DONE_VEX_DECODING_L0_AND_NO_VVVV();
3398 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3399 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
3400
3401 IEM_MC_FETCH_YREG_U64(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3402 IEM_MC_STORE_MEM_U64(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
3403
3404 IEM_MC_ADVANCE_RIP();
3405 IEM_MC_END();
3406 }
3407 return VINF_SUCCESS;
3408}
3409
3410/* Opcode VEX.F3.0F 0xd6 - invalid */
3411/* Opcode VEX.F2.0F 0xd6 - invalid */
3412
3413
3414/* Opcode VEX.0F 0xd7 - invalid */
3415
3416/** Opcode VEX.66.0F 0xd7 - */
3417FNIEMOP_STUB(iemOp_vpmovmskb_Gd_Ux);
3418//FNIEMOP_DEF(iemOp_vpmovmskb_Gd_Ux)
3419//{
3420// /* Note! Taking the lazy approch here wrt the high 32-bits of the GREG. */
3421// /** @todo testcase: Check that the instruction implicitly clears the high
3422// * bits in 64-bit mode. The REX.W is first necessary when VLMAX > 256
3423// * and opcode modifications are made to work with the whole width (not
3424// * just 128). */
3425// IEMOP_MNEMONIC(vpmovmskb_Gd_Nq, "vpmovmskb Gd, Ux");
3426// /* Docs says register only. */
3427// uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
3428// if ((bRm & X86_MODRM_MOD_MASK) == (3 << X86_MODRM_MOD_SHIFT)) /** @todo test that this is registers only. */
3429// {
3430// IEMOP_HLP_DECODED_NL_2(OP_PMOVMSKB, IEMOPFORM_RM_REG, OP_PARM_Gd, OP_PARM_Vdq, DISOPTYPE_SSE | DISOPTYPE_HARMLESS);
3431// IEM_MC_BEGIN(2, 0);
3432// IEM_MC_ARG(uint64_t *, pDst, 0);
3433// IEM_MC_ARG(PCRTUINT128U, pSrc, 1);
3434// IEM_MC_MAYBE_RAISE_SSE2_RELATED_XCPT();
3435// IEM_MC_PREPARE_SSE_USAGE();
3436// IEM_MC_REF_GREG_U64(pDst, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3437// IEM_MC_REF_XREG_U128_CONST(pSrc, (bRm & X86_MODRM_RM_MASK) | pVCpu->iem.s.uRexB);
3438// IEM_MC_CALL_SSE_AIMPL_2(iemAImpl_pmovmskb_u128, pDst, pSrc);
3439// IEM_MC_ADVANCE_RIP();
3440// IEM_MC_END();
3441// return VINF_SUCCESS;
3442// }
3443// return IEMOP_RAISE_INVALID_OPCODE();
3444//}
3445
3446/* Opcode VEX.F3.0F 0xd7 - invalid */
3447/* Opcode VEX.F2.0F 0xd7 - invalid */
3448
3449
3450/* Opcode VEX.0F 0xd8 - invalid */
3451/** Opcode VEX.66.0F 0xd8 - vpsubusb Vx, Hx, W */
3452FNIEMOP_STUB(iemOp_vpsubusb_Vx_Hx_W);
3453/* Opcode VEX.F3.0F 0xd8 - invalid */
3454/* Opcode VEX.F2.0F 0xd8 - invalid */
3455
3456/* Opcode VEX.0F 0xd9 - invalid */
3457/** Opcode VEX.66.0F 0xd9 - vpsubusw Vx, Hx, Wx */
3458FNIEMOP_STUB(iemOp_vpsubusw_Vx_Hx_Wx);
3459/* Opcode VEX.F3.0F 0xd9 - invalid */
3460/* Opcode VEX.F2.0F 0xd9 - invalid */
3461
3462/* Opcode VEX.0F 0xda - invalid */
3463/** Opcode VEX.66.0F 0xda - vpminub Vx, Hx, Wx */
3464FNIEMOP_STUB(iemOp_vpminub_Vx_Hx_Wx);
3465/* Opcode VEX.F3.0F 0xda - invalid */
3466/* Opcode VEX.F2.0F 0xda - invalid */
3467
3468/* Opcode VEX.0F 0xdb - invalid */
3469/** Opcode VEX.66.0F 0xdb - vpand Vx, Hx, W */
3470FNIEMOP_STUB(iemOp_vpand_Vx_Hx_W);
3471/* Opcode VEX.F3.0F 0xdb - invalid */
3472/* Opcode VEX.F2.0F 0xdb - invalid */
3473
3474/* Opcode VEX.0F 0xdc - invalid */
3475/** Opcode VEX.66.0F 0xdc - vpaddusb Vx, Hx, Wx */
3476FNIEMOP_STUB(iemOp_vpaddusb_Vx_Hx_Wx);
3477/* Opcode VEX.F3.0F 0xdc - invalid */
3478/* Opcode VEX.F2.0F 0xdc - invalid */
3479
3480/* Opcode VEX.0F 0xdd - invalid */
3481/** Opcode VEX.66.0F 0xdd - vpaddusw Vx, Hx, Wx */
3482FNIEMOP_STUB(iemOp_vpaddusw_Vx_Hx_Wx);
3483/* Opcode VEX.F3.0F 0xdd - invalid */
3484/* Opcode VEX.F2.0F 0xdd - invalid */
3485
3486/* Opcode VEX.0F 0xde - invalid */
3487/** Opcode VEX.66.0F 0xde - vpmaxub Vx, Hx, W */
3488FNIEMOP_STUB(iemOp_vpmaxub_Vx_Hx_W);
3489/* Opcode VEX.F3.0F 0xde - invalid */
3490/* Opcode VEX.F2.0F 0xde - invalid */
3491
3492/* Opcode VEX.0F 0xdf - invalid */
3493/** Opcode VEX.66.0F 0xdf - vpandn Vx, Hx, Wx */
3494FNIEMOP_STUB(iemOp_vpandn_Vx_Hx_Wx);
3495/* Opcode VEX.F3.0F 0xdf - invalid */
3496/* Opcode VEX.F2.0F 0xdf - invalid */
3497
3498/* Opcode VEX.0F 0xe0 - invalid */
3499/** Opcode VEX.66.0F 0xe0 - vpavgb Vx, Hx, Wx */
3500FNIEMOP_STUB(iemOp_vpavgb_Vx_Hx_Wx);
3501/* Opcode VEX.F3.0F 0xe0 - invalid */
3502/* Opcode VEX.F2.0F 0xe0 - invalid */
3503
3504/* Opcode VEX.0F 0xe1 - invalid */
3505/** Opcode VEX.66.0F 0xe1 - vpsraw Vx, Hx, W */
3506FNIEMOP_STUB(iemOp_vpsraw_Vx_Hx_W);
3507/* Opcode VEX.F3.0F 0xe1 - invalid */
3508/* Opcode VEX.F2.0F 0xe1 - invalid */
3509
3510/* Opcode VEX.0F 0xe2 - invalid */
3511/** Opcode VEX.66.0F 0xe2 - vpsrad Vx, Hx, Wx */
3512FNIEMOP_STUB(iemOp_vpsrad_Vx_Hx_Wx);
3513/* Opcode VEX.F3.0F 0xe2 - invalid */
3514/* Opcode VEX.F2.0F 0xe2 - invalid */
3515
3516/* Opcode VEX.0F 0xe3 - invalid */
3517/** Opcode VEX.66.0F 0xe3 - vpavgw Vx, Hx, Wx */
3518FNIEMOP_STUB(iemOp_vpavgw_Vx_Hx_Wx);
3519/* Opcode VEX.F3.0F 0xe3 - invalid */
3520/* Opcode VEX.F2.0F 0xe3 - invalid */
3521
3522/* Opcode VEX.0F 0xe4 - invalid */
3523/** Opcode VEX.66.0F 0xe4 - vpmulhuw Vx, Hx, W */
3524FNIEMOP_STUB(iemOp_vpmulhuw_Vx_Hx_W);
3525/* Opcode VEX.F3.0F 0xe4 - invalid */
3526/* Opcode VEX.F2.0F 0xe4 - invalid */
3527
3528/* Opcode VEX.0F 0xe5 - invalid */
3529/** Opcode VEX.66.0F 0xe5 - vpmulhw Vx, Hx, Wx */
3530FNIEMOP_STUB(iemOp_vpmulhw_Vx_Hx_Wx);
3531/* Opcode VEX.F3.0F 0xe5 - invalid */
3532/* Opcode VEX.F2.0F 0xe5 - invalid */
3533
3534/* Opcode VEX.0F 0xe6 - invalid */
3535/** Opcode VEX.66.0F 0xe6 - vcvttpd2dq Vx, Wpd */
3536FNIEMOP_STUB(iemOp_vcvttpd2dq_Vx_Wpd);
3537/** Opcode VEX.F3.0F 0xe6 - vcvtdq2pd Vx, Wpd */
3538FNIEMOP_STUB(iemOp_vcvtdq2pd_Vx_Wpd);
3539/** Opcode VEX.F2.0F 0xe6 - vcvtpd2dq Vx, Wpd */
3540FNIEMOP_STUB(iemOp_vcvtpd2dq_Vx_Wpd);
3541
3542
3543/* Opcode VEX.0F 0xe7 - invalid */
3544
3545/**
3546 * @opcode 0xe7
3547 * @opcodesub !11 mr/reg
3548 * @oppfx 0x66
3549 * @opcpuid avx
3550 * @opgroup og_avx_cachect
3551 * @opxcpttype 1
3552 * @optest op1=-1 op2=2 -> op1=2
3553 * @optest op1=0 op2=-42 -> op1=-42
3554 */
3555FNIEMOP_DEF(iemOp_vmovntdq_Mx_Vx)
3556{
3557 IEMOP_MNEMONIC2(VEX_MR_MEM, VMOVNTDQ, vmovntdq, Mx_WO, Vx, DISOPTYPE_HARMLESS, IEMOPHINT_IGNORES_OP_SIZES);
3558 Assert(pVCpu->iem.s.uVexLength <= 1);
3559 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm);
3560 if ((bRm & X86_MODRM_MOD_MASK) != (3 << X86_MODRM_MOD_SHIFT))
3561 {
3562 if (pVCpu->iem.s.uVexLength == 0)
3563 {
3564 /*
3565 * 128-bit: Memory, register.
3566 */
3567 IEM_MC_BEGIN(0, 2);
3568 IEM_MC_LOCAL(RTUINT128U, uSrc);
3569 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
3570
3571 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
3572 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
3573 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3574 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
3575
3576 IEM_MC_FETCH_YREG_U128(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3577 IEM_MC_STORE_MEM_U128_ALIGN_SSE(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
3578
3579 IEM_MC_ADVANCE_RIP();
3580 IEM_MC_END();
3581 }
3582 else
3583 {
3584 /*
3585 * 256-bit: Memory, register.
3586 */
3587 IEM_MC_BEGIN(0, 2);
3588 IEM_MC_LOCAL(RTUINT256U, uSrc);
3589 IEM_MC_LOCAL(RTGCPTR, GCPtrEffSrc);
3590
3591 IEM_MC_CALC_RM_EFF_ADDR(GCPtrEffSrc, bRm, 0);
3592 IEMOP_HLP_DONE_VEX_DECODING_NO_VVVV();
3593 IEM_MC_MAYBE_RAISE_AVX_RELATED_XCPT();
3594 IEM_MC_ACTUALIZE_AVX_STATE_FOR_READ();
3595
3596 IEM_MC_FETCH_YREG_U256(uSrc, ((bRm >> X86_MODRM_REG_SHIFT) & X86_MODRM_REG_SMASK) | pVCpu->iem.s.uRexReg);
3597 IEM_MC_STORE_MEM_U256_ALIGN_AVX(pVCpu->iem.s.iEffSeg, GCPtrEffSrc, uSrc);
3598
3599 IEM_MC_ADVANCE_RIP();
3600 IEM_MC_END();
3601 }
3602 return VINF_SUCCESS;
3603 }
3604 /**
3605 * @opdone
3606 * @opmnemonic udvex660fe7reg
3607 * @opcode 0xe7
3608 * @opcodesub 11 mr/reg
3609 * @oppfx 0x66
3610 * @opunused immediate
3611 * @opcpuid avx
3612 * @optest ->
3613 */
3614 return IEMOP_RAISE_INVALID_OPCODE();
3615}
3616
3617/* Opcode VEX.F3.0F 0xe7 - invalid */
3618/* Opcode VEX.F2.0F 0xe7 - invalid */
3619
3620
3621/* Opcode VEX.0F 0xe8 - invalid */
3622/** Opcode VEX.66.0F 0xe8 - vpsubsb Vx, Hx, W */
3623FNIEMOP_STUB(iemOp_vpsubsb_Vx_Hx_W);
3624/* Opcode VEX.F3.0F 0xe8 - invalid */
3625/* Opcode VEX.F2.0F 0xe8 - invalid */
3626
3627/* Opcode VEX.0F 0xe9 - invalid */
3628/** Opcode VEX.66.0F 0xe9 - vpsubsw Vx, Hx, Wx */
3629FNIEMOP_STUB(iemOp_vpsubsw_Vx_Hx_Wx);
3630/* Opcode VEX.F3.0F 0xe9 - invalid */
3631/* Opcode VEX.F2.0F 0xe9 - invalid */
3632
3633/* Opcode VEX.0F 0xea - invalid */
3634/** Opcode VEX.66.0F 0xea - vpminsw Vx, Hx, Wx */
3635FNIEMOP_STUB(iemOp_vpminsw_Vx_Hx_Wx);
3636/* Opcode VEX.F3.0F 0xea - invalid */
3637/* Opcode VEX.F2.0F 0xea - invalid */
3638
3639/* Opcode VEX.0F 0xeb - invalid */
3640/** Opcode VEX.66.0F 0xeb - vpor Vx, Hx, W */
3641FNIEMOP_STUB(iemOp_vpor_Vx_Hx_W);
3642/* Opcode VEX.F3.0F 0xeb - invalid */
3643/* Opcode VEX.F2.0F 0xeb - invalid */
3644
3645/* Opcode VEX.0F 0xec - invalid */
3646/** Opcode VEX.66.0F 0xec - vpaddsb Vx, Hx, Wx */
3647FNIEMOP_STUB(iemOp_vpaddsb_Vx_Hx_Wx);
3648/* Opcode VEX.F3.0F 0xec - invalid */
3649/* Opcode VEX.F2.0F 0xec - invalid */
3650
3651/* Opcode VEX.0F 0xed - invalid */
3652/** Opcode VEX.66.0F 0xed - vpaddsw Vx, Hx, Wx */
3653FNIEMOP_STUB(iemOp_vpaddsw_Vx_Hx_Wx);
3654/* Opcode VEX.F3.0F 0xed - invalid */
3655/* Opcode VEX.F2.0F 0xed - invalid */
3656
3657/* Opcode VEX.0F 0xee - invalid */
3658/** Opcode VEX.66.0F 0xee - vpmaxsw Vx, Hx, W */
3659FNIEMOP_STUB(iemOp_vpmaxsw_Vx_Hx_W);
3660/* Opcode VEX.F3.0F 0xee - invalid */
3661/* Opcode VEX.F2.0F 0xee - invalid */
3662
3663
3664/* Opcode VEX.0F 0xef - invalid */
3665
3666/** Opcode VEX.66.0F 0xef - vpxor Vx, Hx, Wx */
3667FNIEMOP_DEF(iemOp_vpxor_Vx_Hx_Wx)
3668{
3669 IEMOP_MNEMONIC(vpxor, "vpxor");
3670 return FNIEMOP_CALL_1(iemOpCommonSse2_FullFull_To_Full, &g_iemAImpl_pxor);
3671}
3672
3673/* Opcode VEX.F3.0F 0xef - invalid */
3674/* Opcode VEX.F2.0F 0xef - invalid */
3675
3676/* Opcode VEX.0F 0xf0 - invalid */
3677/* Opcode VEX.66.0F 0xf0 - invalid */
3678/** Opcode VEX.F2.0F 0xf0 - vlddqu Vx, Mx */
3679FNIEMOP_STUB(iemOp_vlddqu_Vx_Mx);
3680
3681/* Opcode VEX.0F 0xf1 - invalid */
3682/** Opcode VEX.66.0F 0xf1 - vpsllw Vx, Hx, W */
3683FNIEMOP_STUB(iemOp_vpsllw_Vx_Hx_W);
3684/* Opcode VEX.F2.0F 0xf1 - invalid */
3685
3686/* Opcode VEX.0F 0xf2 - invalid */
3687/** Opcode VEX.66.0F 0xf2 - vpslld Vx, Hx, Wx */
3688FNIEMOP_STUB(iemOp_vpslld_Vx_Hx_Wx);
3689/* Opcode VEX.F2.0F 0xf2 - invalid */
3690
3691/* Opcode VEX.0F 0xf3 - invalid */
3692/** Opcode VEX.66.0F 0xf3 - vpsllq Vx, Hx, Wx */
3693FNIEMOP_STUB(iemOp_vpsllq_Vx_Hx_Wx);
3694/* Opcode VEX.F2.0F 0xf3 - invalid */
3695
3696/* Opcode VEX.0F 0xf4 - invalid */
3697/** Opcode VEX.66.0F 0xf4 - vpmuludq Vx, Hx, W */
3698FNIEMOP_STUB(iemOp_vpmuludq_Vx_Hx_W);
3699/* Opcode VEX.F2.0F 0xf4 - invalid */
3700
3701/* Opcode VEX.0F 0xf5 - invalid */
3702/** Opcode VEX.66.0F 0xf5 - vpmaddwd Vx, Hx, Wx */
3703FNIEMOP_STUB(iemOp_vpmaddwd_Vx_Hx_Wx);
3704/* Opcode VEX.F2.0F 0xf5 - invalid */
3705
3706/* Opcode VEX.0F 0xf6 - invalid */
3707/** Opcode VEX.66.0F 0xf6 - vpsadbw Vx, Hx, Wx */
3708FNIEMOP_STUB(iemOp_vpsadbw_Vx_Hx_Wx);
3709/* Opcode VEX.F2.0F 0xf6 - invalid */
3710
3711/* Opcode VEX.0F 0xf7 - invalid */
3712/** Opcode VEX.66.0F 0xf7 - vmaskmovdqu Vdq, Udq */
3713FNIEMOP_STUB(iemOp_vmaskmovdqu_Vdq_Udq);
3714/* Opcode VEX.F2.0F 0xf7 - invalid */
3715
3716/* Opcode VEX.0F 0xf8 - invalid */
3717/** Opcode VEX.66.0F 0xf8 - vpsubb Vx, Hx, W */
3718FNIEMOP_STUB(iemOp_vpsubb_Vx_Hx_W);
3719/* Opcode VEX.F2.0F 0xf8 - invalid */
3720
3721/* Opcode VEX.0F 0xf9 - invalid */
3722/** Opcode VEX.66.0F 0xf9 - vpsubw Vx, Hx, Wx */
3723FNIEMOP_STUB(iemOp_vpsubw_Vx_Hx_Wx);
3724/* Opcode VEX.F2.0F 0xf9 - invalid */
3725
3726/* Opcode VEX.0F 0xfa - invalid */
3727/** Opcode VEX.66.0F 0xfa - vpsubd Vx, Hx, Wx */
3728FNIEMOP_STUB(iemOp_vpsubd_Vx_Hx_Wx);
3729/* Opcode VEX.F2.0F 0xfa - invalid */
3730
3731/* Opcode VEX.0F 0xfb - invalid */
3732/** Opcode VEX.66.0F 0xfb - vpsubq Vx, Hx, W */
3733FNIEMOP_STUB(iemOp_vpsubq_Vx_Hx_W);
3734/* Opcode VEX.F2.0F 0xfb - invalid */
3735
3736/* Opcode VEX.0F 0xfc - invalid */
3737/** Opcode VEX.66.0F 0xfc - vpaddb Vx, Hx, Wx */
3738FNIEMOP_STUB(iemOp_vpaddb_Vx_Hx_Wx);
3739/* Opcode VEX.F2.0F 0xfc - invalid */
3740
3741/* Opcode VEX.0F 0xfd - invalid */
3742/** Opcode VEX.66.0F 0xfd - vpaddw Vx, Hx, Wx */
3743FNIEMOP_STUB(iemOp_vpaddw_Vx_Hx_Wx);
3744/* Opcode VEX.F2.0F 0xfd - invalid */
3745
3746/* Opcode VEX.0F 0xfe - invalid */
3747/** Opcode VEX.66.0F 0xfe - vpaddd Vx, Hx, W */
3748FNIEMOP_STUB(iemOp_vpaddd_Vx_Hx_W);
3749/* Opcode VEX.F2.0F 0xfe - invalid */
3750
3751
3752/** Opcode **** 0x0f 0xff - UD0 */
3753FNIEMOP_DEF(iemOp_vud0)
3754{
3755 IEMOP_MNEMONIC(vud0, "vud0");
3756 if (pVCpu->iem.s.enmCpuVendor == CPUMCPUVENDOR_INTEL)
3757 {
3758 uint8_t bRm; IEM_OPCODE_GET_NEXT_U8(&bRm); RT_NOREF(bRm);
3759#ifndef TST_IEM_CHECK_MC
3760 RTGCPTR GCPtrEff;
3761 VBOXSTRICTRC rcStrict = iemOpHlpCalcRmEffAddr(pVCpu, bRm, 0, &GCPtrEff);
3762 if (rcStrict != VINF_SUCCESS)
3763 return rcStrict;
3764#endif
3765 IEMOP_HLP_DONE_DECODING();
3766 }
3767 return IEMOP_RAISE_INVALID_OPCODE();
3768}
3769
3770
3771
3772/**
3773 * VEX opcode map \#1.
3774 *
3775 * @sa g_apfnTwoByteMap
3776 */
3777IEM_STATIC const PFNIEMOP g_apfnVexMap1[] =
3778{
3779 /* no prefix, 066h prefix f3h prefix, f2h prefix */
3780 /* 0x00 */ IEMOP_X4(iemOp_InvalidNeedRM),
3781 /* 0x01 */ IEMOP_X4(iemOp_InvalidNeedRM),
3782 /* 0x02 */ IEMOP_X4(iemOp_InvalidNeedRM),
3783 /* 0x03 */ IEMOP_X4(iemOp_InvalidNeedRM),
3784 /* 0x04 */ IEMOP_X4(iemOp_InvalidNeedRM),
3785 /* 0x05 */ IEMOP_X4(iemOp_InvalidNeedRM),
3786 /* 0x06 */ IEMOP_X4(iemOp_InvalidNeedRM),
3787 /* 0x07 */ IEMOP_X4(iemOp_InvalidNeedRM),
3788 /* 0x08 */ IEMOP_X4(iemOp_InvalidNeedRM),
3789 /* 0x09 */ IEMOP_X4(iemOp_InvalidNeedRM),
3790 /* 0x0a */ IEMOP_X4(iemOp_InvalidNeedRM),
3791 /* 0x0b */ IEMOP_X4(iemOp_vud2), /* ?? */
3792 /* 0x0c */ IEMOP_X4(iemOp_InvalidNeedRM),
3793 /* 0x0d */ IEMOP_X4(iemOp_InvalidNeedRM),
3794 /* 0x0e */ IEMOP_X4(iemOp_InvalidNeedRM),
3795 /* 0x0f */ IEMOP_X4(iemOp_InvalidNeedRM),
3796
3797 /* 0x10 */ iemOp_vmovups_Vps_Wps, iemOp_vmovupd_Vpd_Wpd, iemOp_vmovss_Vss_Hss_Wss, iemOp_vmovsd_Vsd_Hsd_Wsd,
3798 /* 0x11 */ iemOp_vmovups_Wps_Vps, iemOp_vmovupd_Wpd_Vpd, iemOp_vmovss_Wss_Hss_Vss, iemOp_vmovsd_Wsd_Hsd_Vsd,
3799 /* 0x12 */ iemOp_vmovlps_Vq_Hq_Mq__vmovhlps, iemOp_vmovlpd_Vq_Hq_Mq, iemOp_vmovsldup_Vx_Wx, iemOp_vmovddup_Vx_Wx,
3800 /* 0x13 */ iemOp_vmovlps_Mq_Vq, iemOp_vmovlpd_Mq_Vq, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3801 /* 0x14 */ iemOp_vunpcklps_Vx_Hx_Wx, iemOp_vunpcklpd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3802 /* 0x15 */ iemOp_vunpckhps_Vx_Hx_Wx, iemOp_vunpckhpd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3803 /* 0x16 */ iemOp_vmovhpsv1_Vdq_Hq_Mq__vmovlhps_Vdq_Hq_Uq, iemOp_vmovhpdv1_Vdq_Hq_Mq, iemOp_vmovshdup_Vx_Wx, iemOp_InvalidNeedRM,
3804 /* 0x17 */ iemOp_vmovhpsv1_Mq_Vq, iemOp_vmovhpdv1_Mq_Vq, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3805 /* 0x18 */ IEMOP_X4(iemOp_InvalidNeedRM),
3806 /* 0x19 */ IEMOP_X4(iemOp_InvalidNeedRM),
3807 /* 0x1a */ IEMOP_X4(iemOp_InvalidNeedRM),
3808 /* 0x1b */ IEMOP_X4(iemOp_InvalidNeedRM),
3809 /* 0x1c */ IEMOP_X4(iemOp_InvalidNeedRM),
3810 /* 0x1d */ IEMOP_X4(iemOp_InvalidNeedRM),
3811 /* 0x1e */ IEMOP_X4(iemOp_InvalidNeedRM),
3812 /* 0x1f */ IEMOP_X4(iemOp_InvalidNeedRM),
3813
3814 /* 0x20 */ IEMOP_X4(iemOp_InvalidNeedRM),
3815 /* 0x21 */ IEMOP_X4(iemOp_InvalidNeedRM),
3816 /* 0x22 */ IEMOP_X4(iemOp_InvalidNeedRM),
3817 /* 0x23 */ IEMOP_X4(iemOp_InvalidNeedRM),
3818 /* 0x24 */ IEMOP_X4(iemOp_InvalidNeedRM),
3819 /* 0x25 */ IEMOP_X4(iemOp_InvalidNeedRM),
3820 /* 0x26 */ IEMOP_X4(iemOp_InvalidNeedRM),
3821 /* 0x27 */ IEMOP_X4(iemOp_InvalidNeedRM),
3822 /* 0x28 */ iemOp_vmovaps_Vps_Wps, iemOp_vmovapd_Vpd_Wpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3823 /* 0x29 */ iemOp_vmovaps_Wps_Vps, iemOp_vmovapd_Wpd_Vpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3824 /* 0x2a */ iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_vcvtsi2ss_Vss_Hss_Ey, iemOp_vcvtsi2sd_Vsd_Hsd_Ey,
3825 /* 0x2b */ iemOp_vmovntps_Mps_Vps, iemOp_vmovntpd_Mpd_Vpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3826 /* 0x2c */ iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_vcvttss2si_Gy_Wss, iemOp_vcvttsd2si_Gy_Wsd,
3827 /* 0x2d */ iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_vcvtss2si_Gy_Wss, iemOp_vcvtsd2si_Gy_Wsd,
3828 /* 0x2e */ iemOp_vucomiss_Vss_Wss, iemOp_vucomisd_Vsd_Wsd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3829 /* 0x2f */ iemOp_vcomiss_Vss_Wss, iemOp_vcomisd_Vsd_Wsd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3830
3831 /* 0x30 */ IEMOP_X4(iemOp_InvalidNeedRM),
3832 /* 0x31 */ IEMOP_X4(iemOp_InvalidNeedRM),
3833 /* 0x32 */ IEMOP_X4(iemOp_InvalidNeedRM),
3834 /* 0x33 */ IEMOP_X4(iemOp_InvalidNeedRM),
3835 /* 0x34 */ IEMOP_X4(iemOp_InvalidNeedRM),
3836 /* 0x35 */ IEMOP_X4(iemOp_InvalidNeedRM),
3837 /* 0x36 */ IEMOP_X4(iemOp_InvalidNeedRM),
3838 /* 0x37 */ IEMOP_X4(iemOp_InvalidNeedRM),
3839 /* 0x38 */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3840 /* 0x39 */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3841 /* 0x3a */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3842 /* 0x3b */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3843 /* 0x3c */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3844 /* 0x3d */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3845 /* 0x3e */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3846 /* 0x3f */ IEMOP_X4(iemOp_InvalidNeedRM), /** @todo check that there is no escape table stuff here */
3847
3848 /* 0x40 */ IEMOP_X4(iemOp_InvalidNeedRM),
3849 /* 0x41 */ IEMOP_X4(iemOp_InvalidNeedRM),
3850 /* 0x42 */ IEMOP_X4(iemOp_InvalidNeedRM),
3851 /* 0x43 */ IEMOP_X4(iemOp_InvalidNeedRM),
3852 /* 0x44 */ IEMOP_X4(iemOp_InvalidNeedRM),
3853 /* 0x45 */ IEMOP_X4(iemOp_InvalidNeedRM),
3854 /* 0x46 */ IEMOP_X4(iemOp_InvalidNeedRM),
3855 /* 0x47 */ IEMOP_X4(iemOp_InvalidNeedRM),
3856 /* 0x48 */ IEMOP_X4(iemOp_InvalidNeedRM),
3857 /* 0x49 */ IEMOP_X4(iemOp_InvalidNeedRM),
3858 /* 0x4a */ IEMOP_X4(iemOp_InvalidNeedRM),
3859 /* 0x4b */ IEMOP_X4(iemOp_InvalidNeedRM),
3860 /* 0x4c */ IEMOP_X4(iemOp_InvalidNeedRM),
3861 /* 0x4d */ IEMOP_X4(iemOp_InvalidNeedRM),
3862 /* 0x4e */ IEMOP_X4(iemOp_InvalidNeedRM),
3863 /* 0x4f */ IEMOP_X4(iemOp_InvalidNeedRM),
3864
3865 /* 0x50 */ iemOp_vmovmskps_Gy_Ups, iemOp_vmovmskpd_Gy_Upd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3866 /* 0x51 */ iemOp_vsqrtps_Vps_Wps, iemOp_vsqrtpd_Vpd_Wpd, iemOp_vsqrtss_Vss_Hss_Wss, iemOp_vsqrtsd_Vsd_Hsd_Wsd,
3867 /* 0x52 */ iemOp_vrsqrtps_Vps_Wps, iemOp_InvalidNeedRM, iemOp_vrsqrtss_Vss_Hss_Wss, iemOp_InvalidNeedRM,
3868 /* 0x53 */ iemOp_vrcpps_Vps_Wps, iemOp_InvalidNeedRM, iemOp_vrcpss_Vss_Hss_Wss, iemOp_InvalidNeedRM,
3869 /* 0x54 */ iemOp_vandps_Vps_Hps_Wps, iemOp_vandpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3870 /* 0x55 */ iemOp_vandnps_Vps_Hps_Wps, iemOp_vandnpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3871 /* 0x56 */ iemOp_vorps_Vps_Hps_Wps, iemOp_vorpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3872 /* 0x57 */ iemOp_vxorps_Vps_Hps_Wps, iemOp_vxorpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3873 /* 0x58 */ iemOp_vaddps_Vps_Hps_Wps, iemOp_vaddpd_Vpd_Hpd_Wpd, iemOp_vaddss_Vss_Hss_Wss, iemOp_vaddsd_Vsd_Hsd_Wsd,
3874 /* 0x59 */ iemOp_vmulps_Vps_Hps_Wps, iemOp_vmulpd_Vpd_Hpd_Wpd, iemOp_vmulss_Vss_Hss_Wss, iemOp_vmulsd_Vsd_Hsd_Wsd,
3875 /* 0x5a */ iemOp_vcvtps2pd_Vpd_Wps, iemOp_vcvtpd2ps_Vps_Wpd, iemOp_vcvtss2sd_Vsd_Hx_Wss, iemOp_vcvtsd2ss_Vss_Hx_Wsd,
3876 /* 0x5b */ iemOp_vcvtdq2ps_Vps_Wdq, iemOp_vcvtps2dq_Vdq_Wps, iemOp_vcvttps2dq_Vdq_Wps, iemOp_InvalidNeedRM,
3877 /* 0x5c */ iemOp_vsubps_Vps_Hps_Wps, iemOp_vsubpd_Vpd_Hpd_Wpd, iemOp_vsubss_Vss_Hss_Wss, iemOp_vsubsd_Vsd_Hsd_Wsd,
3878 /* 0x5d */ iemOp_vminps_Vps_Hps_Wps, iemOp_vminpd_Vpd_Hpd_Wpd, iemOp_vminss_Vss_Hss_Wss, iemOp_vminsd_Vsd_Hsd_Wsd,
3879 /* 0x5e */ iemOp_vdivps_Vps_Hps_Wps, iemOp_vdivpd_Vpd_Hpd_Wpd, iemOp_vdivss_Vss_Hss_Wss, iemOp_vdivsd_Vsd_Hsd_Wsd,
3880 /* 0x5f */ iemOp_vmaxps_Vps_Hps_Wps, iemOp_vmaxpd_Vpd_Hpd_Wpd, iemOp_vmaxss_Vss_Hss_Wss, iemOp_vmaxsd_Vsd_Hsd_Wsd,
3881
3882 /* 0x60 */ iemOp_InvalidNeedRM, iemOp_vpunpcklbw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3883 /* 0x61 */ iemOp_InvalidNeedRM, iemOp_vpunpcklwd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3884 /* 0x62 */ iemOp_InvalidNeedRM, iemOp_vpunpckldq_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3885 /* 0x63 */ iemOp_InvalidNeedRM, iemOp_vpacksswb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3886 /* 0x64 */ iemOp_InvalidNeedRM, iemOp_vpcmpgtb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3887 /* 0x65 */ iemOp_InvalidNeedRM, iemOp_vpcmpgtw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3888 /* 0x66 */ iemOp_InvalidNeedRM, iemOp_vpcmpgtd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3889 /* 0x67 */ iemOp_InvalidNeedRM, iemOp_vpackuswb_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3890 /* 0x68 */ iemOp_InvalidNeedRM, iemOp_vpunpckhbw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3891 /* 0x69 */ iemOp_InvalidNeedRM, iemOp_vpunpckhwd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3892 /* 0x6a */ iemOp_InvalidNeedRM, iemOp_vpunpckhdq_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3893 /* 0x6b */ iemOp_InvalidNeedRM, iemOp_vpackssdw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3894 /* 0x6c */ iemOp_InvalidNeedRM, iemOp_vpunpcklqdq_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3895 /* 0x6d */ iemOp_InvalidNeedRM, iemOp_vpunpckhqdq_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3896 /* 0x6e */ iemOp_InvalidNeedRM, iemOp_vmovd_q_Vy_Ey, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3897 /* 0x6f */ iemOp_InvalidNeedRM, iemOp_vmovdqa_Vx_Wx, iemOp_vmovdqu_Vx_Wx, iemOp_InvalidNeedRM,
3898
3899 /* 0x70 */ iemOp_InvalidNeedRM, iemOp_vpshufd_Vx_Wx_Ib, iemOp_vpshufhw_Vx_Wx_Ib, iemOp_vpshuflw_Vx_Wx_Ib,
3900 /* 0x71 */ iemOp_InvalidNeedRM, iemOp_VGrp12, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3901 /* 0x72 */ iemOp_InvalidNeedRM, iemOp_VGrp13, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3902 /* 0x73 */ iemOp_InvalidNeedRM, iemOp_VGrp14, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3903 /* 0x74 */ iemOp_InvalidNeedRM, iemOp_vpcmpeqb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3904 /* 0x75 */ iemOp_InvalidNeedRM, iemOp_vpcmpeqw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3905 /* 0x76 */ iemOp_InvalidNeedRM, iemOp_vpcmpeqd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3906 /* 0x77 */ iemOp_vzeroupperv__vzeroallv, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
3907 /* 0x78 */ IEMOP_X4(iemOp_InvalidNeedRM),
3908 /* 0x79 */ IEMOP_X4(iemOp_InvalidNeedRM),
3909 /* 0x7a */ IEMOP_X4(iemOp_InvalidNeedRM),
3910 /* 0x7b */ IEMOP_X4(iemOp_InvalidNeedRM),
3911 /* 0x7c */ iemOp_InvalidNeedRM, iemOp_vhaddpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_vhaddps_Vps_Hps_Wps,
3912 /* 0x7d */ iemOp_InvalidNeedRM, iemOp_vhsubpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_vhsubps_Vps_Hps_Wps,
3913 /* 0x7e */ iemOp_InvalidNeedRM, iemOp_vmovd_q_Ey_Vy, iemOp_vmovq_Vq_Wq, iemOp_InvalidNeedRM,
3914 /* 0x7f */ iemOp_InvalidNeedRM, iemOp_vmovdqa_Wx_Vx, iemOp_vmovdqu_Wx_Vx, iemOp_InvalidNeedRM,
3915
3916 /* 0x80 */ IEMOP_X4(iemOp_InvalidNeedRM),
3917 /* 0x81 */ IEMOP_X4(iemOp_InvalidNeedRM),
3918 /* 0x82 */ IEMOP_X4(iemOp_InvalidNeedRM),
3919 /* 0x83 */ IEMOP_X4(iemOp_InvalidNeedRM),
3920 /* 0x84 */ IEMOP_X4(iemOp_InvalidNeedRM),
3921 /* 0x85 */ IEMOP_X4(iemOp_InvalidNeedRM),
3922 /* 0x86 */ IEMOP_X4(iemOp_InvalidNeedRM),
3923 /* 0x87 */ IEMOP_X4(iemOp_InvalidNeedRM),
3924 /* 0x88 */ IEMOP_X4(iemOp_InvalidNeedRM),
3925 /* 0x89 */ IEMOP_X4(iemOp_InvalidNeedRM),
3926 /* 0x8a */ IEMOP_X4(iemOp_InvalidNeedRM),
3927 /* 0x8b */ IEMOP_X4(iemOp_InvalidNeedRM),
3928 /* 0x8c */ IEMOP_X4(iemOp_InvalidNeedRM),
3929 /* 0x8d */ IEMOP_X4(iemOp_InvalidNeedRM),
3930 /* 0x8e */ IEMOP_X4(iemOp_InvalidNeedRM),
3931 /* 0x8f */ IEMOP_X4(iemOp_InvalidNeedRM),
3932
3933 /* 0x90 */ IEMOP_X4(iemOp_InvalidNeedRM),
3934 /* 0x91 */ IEMOP_X4(iemOp_InvalidNeedRM),
3935 /* 0x92 */ IEMOP_X4(iemOp_InvalidNeedRM),
3936 /* 0x93 */ IEMOP_X4(iemOp_InvalidNeedRM),
3937 /* 0x94 */ IEMOP_X4(iemOp_InvalidNeedRM),
3938 /* 0x95 */ IEMOP_X4(iemOp_InvalidNeedRM),
3939 /* 0x96 */ IEMOP_X4(iemOp_InvalidNeedRM),
3940 /* 0x97 */ IEMOP_X4(iemOp_InvalidNeedRM),
3941 /* 0x98 */ IEMOP_X4(iemOp_InvalidNeedRM),
3942 /* 0x99 */ IEMOP_X4(iemOp_InvalidNeedRM),
3943 /* 0x9a */ IEMOP_X4(iemOp_InvalidNeedRM),
3944 /* 0x9b */ IEMOP_X4(iemOp_InvalidNeedRM),
3945 /* 0x9c */ IEMOP_X4(iemOp_InvalidNeedRM),
3946 /* 0x9d */ IEMOP_X4(iemOp_InvalidNeedRM),
3947 /* 0x9e */ IEMOP_X4(iemOp_InvalidNeedRM),
3948 /* 0x9f */ IEMOP_X4(iemOp_InvalidNeedRM),
3949
3950 /* 0xa0 */ IEMOP_X4(iemOp_InvalidNeedRM),
3951 /* 0xa1 */ IEMOP_X4(iemOp_InvalidNeedRM),
3952 /* 0xa2 */ IEMOP_X4(iemOp_InvalidNeedRM),
3953 /* 0xa3 */ IEMOP_X4(iemOp_InvalidNeedRM),
3954 /* 0xa4 */ IEMOP_X4(iemOp_InvalidNeedRM),
3955 /* 0xa5 */ IEMOP_X4(iemOp_InvalidNeedRM),
3956 /* 0xa6 */ IEMOP_X4(iemOp_InvalidNeedRM),
3957 /* 0xa7 */ IEMOP_X4(iemOp_InvalidNeedRM),
3958 /* 0xa8 */ IEMOP_X4(iemOp_InvalidNeedRM),
3959 /* 0xa9 */ IEMOP_X4(iemOp_InvalidNeedRM),
3960 /* 0xaa */ IEMOP_X4(iemOp_InvalidNeedRM),
3961 /* 0xab */ IEMOP_X4(iemOp_InvalidNeedRM),
3962 /* 0xac */ IEMOP_X4(iemOp_InvalidNeedRM),
3963 /* 0xad */ IEMOP_X4(iemOp_InvalidNeedRM),
3964 /* 0xae */ IEMOP_X4(iemOp_VGrp15),
3965 /* 0xaf */ IEMOP_X4(iemOp_InvalidNeedRM),
3966
3967 /* 0xb0 */ IEMOP_X4(iemOp_InvalidNeedRM),
3968 /* 0xb1 */ IEMOP_X4(iemOp_InvalidNeedRM),
3969 /* 0xb2 */ IEMOP_X4(iemOp_InvalidNeedRM),
3970 /* 0xb3 */ IEMOP_X4(iemOp_InvalidNeedRM),
3971 /* 0xb4 */ IEMOP_X4(iemOp_InvalidNeedRM),
3972 /* 0xb5 */ IEMOP_X4(iemOp_InvalidNeedRM),
3973 /* 0xb6 */ IEMOP_X4(iemOp_InvalidNeedRM),
3974 /* 0xb7 */ IEMOP_X4(iemOp_InvalidNeedRM),
3975 /* 0xb8 */ IEMOP_X4(iemOp_InvalidNeedRM),
3976 /* 0xb9 */ IEMOP_X4(iemOp_InvalidNeedRM),
3977 /* 0xba */ IEMOP_X4(iemOp_InvalidNeedRM),
3978 /* 0xbb */ IEMOP_X4(iemOp_InvalidNeedRM),
3979 /* 0xbc */ IEMOP_X4(iemOp_InvalidNeedRM),
3980 /* 0xbd */ IEMOP_X4(iemOp_InvalidNeedRM),
3981 /* 0xbe */ IEMOP_X4(iemOp_InvalidNeedRM),
3982 /* 0xbf */ IEMOP_X4(iemOp_InvalidNeedRM),
3983
3984 /* 0xc0 */ IEMOP_X4(iemOp_InvalidNeedRM),
3985 /* 0xc1 */ IEMOP_X4(iemOp_InvalidNeedRM),
3986 /* 0xc2 */ iemOp_vcmpps_Vps_Hps_Wps_Ib, iemOp_vcmppd_Vpd_Hpd_Wpd_Ib, iemOp_vcmpss_Vss_Hss_Wss_Ib, iemOp_vcmpsd_Vsd_Hsd_Wsd_Ib,
3987 /* 0xc3 */ IEMOP_X4(iemOp_InvalidNeedRM),
3988 /* 0xc4 */ iemOp_InvalidNeedRM, iemOp_vpinsrw_Vdq_Hdq_RyMw_Ib, iemOp_InvalidNeedRMImm8, iemOp_InvalidNeedRMImm8,
3989 /* 0xc5 */ iemOp_InvalidNeedRM, iemOp_vpextrw_Gd_Udq_Ib, iemOp_InvalidNeedRMImm8, iemOp_InvalidNeedRMImm8,
3990 /* 0xc6 */ iemOp_vshufps_Vps_Hps_Wps_Ib, iemOp_vshufpd_Vpd_Hpd_Wpd_Ib, iemOp_InvalidNeedRMImm8,iemOp_InvalidNeedRMImm8,
3991 /* 0xc7 */ IEMOP_X4(iemOp_InvalidNeedRM),
3992 /* 0xc8 */ IEMOP_X4(iemOp_InvalidNeedRM),
3993 /* 0xc9 */ IEMOP_X4(iemOp_InvalidNeedRM),
3994 /* 0xca */ IEMOP_X4(iemOp_InvalidNeedRM),
3995 /* 0xcb */ IEMOP_X4(iemOp_InvalidNeedRM),
3996 /* 0xcc */ IEMOP_X4(iemOp_InvalidNeedRM),
3997 /* 0xcd */ IEMOP_X4(iemOp_InvalidNeedRM),
3998 /* 0xce */ IEMOP_X4(iemOp_InvalidNeedRM),
3999 /* 0xcf */ IEMOP_X4(iemOp_InvalidNeedRM),
4000
4001 /* 0xd0 */ iemOp_InvalidNeedRM, iemOp_vaddsubpd_Vpd_Hpd_Wpd, iemOp_InvalidNeedRM, iemOp_vaddsubps_Vps_Hps_Wps,
4002 /* 0xd1 */ iemOp_InvalidNeedRM, iemOp_vpsrlw_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4003 /* 0xd2 */ iemOp_InvalidNeedRM, iemOp_vpsrld_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4004 /* 0xd3 */ iemOp_InvalidNeedRM, iemOp_vpsrlq_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4005 /* 0xd4 */ iemOp_InvalidNeedRM, iemOp_vpaddq_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4006 /* 0xd5 */ iemOp_InvalidNeedRM, iemOp_vpmullw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4007 /* 0xd6 */ iemOp_InvalidNeedRM, iemOp_vmovq_Wq_Vq, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4008 /* 0xd7 */ iemOp_InvalidNeedRM, iemOp_vpmovmskb_Gd_Ux, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4009 /* 0xd8 */ iemOp_InvalidNeedRM, iemOp_vpsubusb_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4010 /* 0xd9 */ iemOp_InvalidNeedRM, iemOp_vpsubusw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4011 /* 0xda */ iemOp_InvalidNeedRM, iemOp_vpminub_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4012 /* 0xdb */ iemOp_InvalidNeedRM, iemOp_vpand_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4013 /* 0xdc */ iemOp_InvalidNeedRM, iemOp_vpaddusb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4014 /* 0xdd */ iemOp_InvalidNeedRM, iemOp_vpaddusw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4015 /* 0xde */ iemOp_InvalidNeedRM, iemOp_vpmaxub_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4016 /* 0xdf */ iemOp_InvalidNeedRM, iemOp_vpandn_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4017
4018 /* 0xe0 */ iemOp_InvalidNeedRM, iemOp_vpavgb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4019 /* 0xe1 */ iemOp_InvalidNeedRM, iemOp_vpsraw_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4020 /* 0xe2 */ iemOp_InvalidNeedRM, iemOp_vpsrad_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4021 /* 0xe3 */ iemOp_InvalidNeedRM, iemOp_vpavgw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4022 /* 0xe4 */ iemOp_InvalidNeedRM, iemOp_vpmulhuw_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4023 /* 0xe5 */ iemOp_InvalidNeedRM, iemOp_vpmulhw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4024 /* 0xe6 */ iemOp_InvalidNeedRM, iemOp_vcvttpd2dq_Vx_Wpd, iemOp_vcvtdq2pd_Vx_Wpd, iemOp_vcvtpd2dq_Vx_Wpd,
4025 /* 0xe7 */ iemOp_InvalidNeedRM, iemOp_vmovntdq_Mx_Vx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4026 /* 0xe8 */ iemOp_InvalidNeedRM, iemOp_vpsubsb_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4027 /* 0xe9 */ iemOp_InvalidNeedRM, iemOp_vpsubsw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4028 /* 0xea */ iemOp_InvalidNeedRM, iemOp_vpminsw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4029 /* 0xeb */ iemOp_InvalidNeedRM, iemOp_vpor_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4030 /* 0xec */ iemOp_InvalidNeedRM, iemOp_vpaddsb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4031 /* 0xed */ iemOp_InvalidNeedRM, iemOp_vpaddsw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4032 /* 0xee */ iemOp_InvalidNeedRM, iemOp_vpmaxsw_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4033 /* 0xef */ iemOp_InvalidNeedRM, iemOp_vpxor_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4034
4035 /* 0xf0 */ iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM, iemOp_vlddqu_Vx_Mx,
4036 /* 0xf1 */ iemOp_InvalidNeedRM, iemOp_vpsllw_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4037 /* 0xf2 */ iemOp_InvalidNeedRM, iemOp_vpslld_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4038 /* 0xf3 */ iemOp_InvalidNeedRM, iemOp_vpsllq_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4039 /* 0xf4 */ iemOp_InvalidNeedRM, iemOp_vpmuludq_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4040 /* 0xf5 */ iemOp_InvalidNeedRM, iemOp_vpmaddwd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4041 /* 0xf6 */ iemOp_InvalidNeedRM, iemOp_vpsadbw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4042 /* 0xf7 */ iemOp_InvalidNeedRM, iemOp_vmaskmovdqu_Vdq_Udq, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4043 /* 0xf8 */ iemOp_InvalidNeedRM, iemOp_vpsubb_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4044 /* 0xf9 */ iemOp_InvalidNeedRM, iemOp_vpsubw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4045 /* 0xfa */ iemOp_InvalidNeedRM, iemOp_vpsubd_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4046 /* 0xfb */ iemOp_InvalidNeedRM, iemOp_vpsubq_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4047 /* 0xfc */ iemOp_InvalidNeedRM, iemOp_vpaddb_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4048 /* 0xfd */ iemOp_InvalidNeedRM, iemOp_vpaddw_Vx_Hx_Wx, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4049 /* 0xfe */ iemOp_InvalidNeedRM, iemOp_vpaddd_Vx_Hx_W, iemOp_InvalidNeedRM, iemOp_InvalidNeedRM,
4050 /* 0xff */ IEMOP_X4(iemOp_vud0) /* ?? */
4051};
4052AssertCompile(RT_ELEMENTS(g_apfnVexMap1) == 1024);
4053/** @} */
4054
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette