VirtualBox

source: vbox/trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-generated-1-template.c@ 82968

Last change on this file since 82968 was 82968, checked in by vboxsync, 5 years ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 265.7 KB
Line 
1/* $Id: bs3-cpu-generated-1-template.c 82968 2020-02-04 10:35:17Z vboxsync $ */
2/** @file
3 * BS3Kit - bs3-cpu-generated-1, C code template.
4 */
5
6/*
7 * Copyright (C) 2007-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27#ifndef BS3_INSTANTIATING_CMN
28# error "BS3_INSTANTIATING_CMN not defined"
29#endif
30
31
32/*********************************************************************************************************************************
33* Header Files *
34*********************************************************************************************************************************/
35#include <iprt/asm.h>
36#include <iprt/asm-amd64-x86.h>
37
38#include "bs3-cpu-generated-1.h"
39
40
41/*********************************************************************************************************************************
42* Defined Constants And Macros *
43*********************************************************************************************************************************/
44#define BS3CG1_WITH_VEX
45
46#define P_CS X86_OP_PRF_CS
47#define P_SS X86_OP_PRF_SS
48#define P_DS X86_OP_PRF_DS
49#define P_ES X86_OP_PRF_ES
50#define P_FS X86_OP_PRF_FS
51#define P_GS X86_OP_PRF_GS
52#define P_OZ X86_OP_PRF_SIZE_OP
53#define P_AZ X86_OP_PRF_SIZE_ADDR
54#define P_LK X86_OP_PRF_LOCK
55#define P_RN X86_OP_PRF_REPNZ
56#define P_RZ X86_OP_PRF_REPZ
57
58#define REX_WRBX (X86_OP_REX_W | X86_OP_REX_R | X86_OP_REX_B | X86_OP_REX_X)
59#define REX_W___ (X86_OP_REX_W)
60#define REX_WR__ (X86_OP_REX_W | X86_OP_REX_R)
61#define REX_W_B_ (X86_OP_REX_W | X86_OP_REX_B)
62#define REX_W__X (X86_OP_REX_W | X86_OP_REX_X)
63#define REX_WRB_ (X86_OP_REX_W | X86_OP_REX_R | X86_OP_REX_B)
64#define REX_WR_X (X86_OP_REX_W | X86_OP_REX_R | X86_OP_REX_X)
65#define REX_W_BX (X86_OP_REX_W | X86_OP_REX_B | X86_OP_REX_X)
66#define REX__R__ (X86_OP_REX_R)
67#define REX__RB_ (X86_OP_REX_R | X86_OP_REX_B)
68#define REX__R_X (X86_OP_REX_R | X86_OP_REX_X)
69#define REX__RBX (X86_OP_REX_R | X86_OP_REX_B | X86_OP_REX_X)
70#define REX___B_ (X86_OP_REX_B)
71#define REX___BX (X86_OP_REX_B | X86_OP_REX_X)
72#define REX____X (X86_OP_REX_X)
73#define REX_____ (0x40)
74
75
76/** @def BS3CG1_DPRINTF
77 * Debug print macro.
78 */
79#if 0
80# define BS3CG1_DPRINTF(a_ArgList) Bs3TestPrintf a_ArgList
81# define BS3CG1_DEBUG_CTX_MOD
82#else
83# define BS3CG1_DPRINTF(a_ArgList) do { } while (0)
84#endif
85
86/**
87 * Checks if this is a 64-bit test target or not.
88 * Helps avoid ifdefs or code bloat.
89 */
90#if ARCH_BITS == 64
91# define BS3CG1_IS_64BIT_TARGET(a_pThis) BS3_MODE_IS_64BIT_CODE((a_pThis)->bMode)
92#else
93# define BS3CG1_IS_64BIT_TARGET(a_pThis) (false)
94#endif
95
96
97/*********************************************************************************************************************************
98* Structures and Typedefs *
99*********************************************************************************************************************************/
100/** Operand value location. */
101typedef enum BS3CG1OPLOC
102{
103 BS3CG1OPLOC_INVALID = 0,
104 BS3CG1OPLOC_CTX,
105 BS3CG1OPLOC_CTX_ZX_VLMAX,
106 BS3CG1OPLOC_IMM,
107 BS3CG1OPLOC_MEM,
108 BS3CG1OPLOC_MEM_RW,
109 BS3CG1OPLOC_MEM_WO,
110 BS3CG1OPLOC_END
111} BS3CG1OPLOC;
112AssertCompile(BS3CG1OPLOC_END <= 16);
113
114
115/** Pointer to the generated test state. */
116typedef struct BS3CG1STATE *PBS3CG1STATE;
117
118/**
119 * Encoder callback.
120 * @returns Next encoding. If equal or less to @a iEncoding, no
121 * further encodings are available for testing.
122 * @param pThis The state.
123 * @param iEncoding The encoding.
124 */
125typedef unsigned BS3_NEAR_CODE FNBS3CG1ENCODER(PBS3CG1STATE pThis, unsigned iEncoding);
126/** Pointer to a encoder callback. */
127typedef FNBS3CG1ENCODER *PFNBS3CG1ENCODER;
128
129
130/**
131 * The state.
132 */
133typedef struct BS3CG1STATE
134{
135 /** @name Instruction details (expanded from BS3CG1INSTR).
136 * @{ */
137 /** Pointer to the mnemonic string (not terminated) (g_achBs3Cg1Mnemonics). */
138 const char BS3_FAR *pchMnemonic;
139 /** Pointer to the test header. */
140 PCBS3CG1TESTHDR pTestHdr;
141 /** Pointer to the per operand flags (g_abBs3Cg1Operands). */
142 const uint8_t BS3_FAR *pabOperands;
143 /** Opcode bytes (g_abBs3Cg1Opcodes). */
144 const uint8_t BS3_FAR *pabOpcodes;
145 /** The current instruction number in the input array (for error reporting). */
146 uint32_t iInstr;
147
148 /** The instruction flags. */
149 uint32_t fFlags;
150 /** The encoding. */
151 BS3CG1ENC enmEncoding;
152 /** The non-invalid encoding. This may differ from enmEncoding when
153 * Bs3Cg1CalcNoneIntelInvalidEncoding has been called. */
154 BS3CG1ENC enmEncodingNonInvalid;
155 /** The CPU test / CPU ID. */
156 BS3CG1CPU enmCpuTest;
157 /** Prefix sensitivity and requirements. */
158 BS3CG1PFXKIND enmPrefixKind;
159 /** Exception type (SSE, AVX). */
160 BS3CG1XCPTTYPE enmXcptType;
161 /** Per operand flags. */
162 BS3CG1OP aenmOperands[4];
163 /** Opcode bytes. */
164 uint8_t abOpcodes[4];
165 /** The instruction encoder. */
166 PFNBS3CG1ENCODER pfnEncoder;
167
168 /** The length of the mnemonic. */
169 uint8_t cchMnemonic;
170 /** Whether to advance the mnemonic pointer or not. */
171 uint8_t fAdvanceMnemonic;
172 /** The opcode map number. */
173 uint8_t uOpcodeMap;
174 /** The number of opcode bytes. */
175 uint8_t cbOpcodes;
176 /** Number of operands. */
177 uint8_t cOperands;
178 /** @} */
179
180 /** Default operand size. */
181 uint8_t cbOpDefault;
182 /** Operand size when overridden by 066h. */
183 uint8_t cbOpOvrd66;
184 /** Operand size when overridden by REX.W. */
185 uint8_t cbOpOvrdRexW;
186
187 /** Operand size in bytes (0 if not applicable). */
188 uint8_t cbOperand;
189 /** Current VEX.L value (UINT8_MAX if not applicable). */
190 uint8_t uVexL;
191 /** Current target ring (0..3). */
192 uint8_t uCpl;
193
194 /** The current test number. */
195 uint8_t iTest;
196
197 /** Target mode (g_bBs3CurrentMode). */
198 uint8_t bMode;
199 /** The CPU vendor (BS3CPUVENDOR). */
200 uint8_t bCpuVendor;
201 /** First ring being tested. */
202 uint8_t iFirstRing;
203 /** End of rings being tested. */
204 uint8_t iEndRing;
205
206 /** @name Current encoded instruction.
207 * @{ */
208 /** The size of the current instruction that we're testing. */
209 uint8_t cbCurInstr;
210 /** The size the prefixes. */
211 uint8_t cbCurPrefix;
212 /** The offset into abCurInstr of the immediate. */
213 uint8_t offCurImm;
214 /** Buffer for assembling the current instruction. */
215 uint8_t abCurInstr[23];
216
217 /** Set if the encoding can't be tested in the same ring as this test code.
218 * This is used to deal with encodings modifying SP/ESP/RSP. */
219 bool fSameRingNotOkay;
220 /** Whether to work the extended context too. */
221 bool fWorkExtCtx;
222 /** The aOperands index of the modrm.reg operand (if applicable). */
223 uint8_t iRegOp;
224 /** The aOperands index of the modrm.rm operand (if applicable). */
225 uint8_t iRmOp;
226
227 /** Operands details. */
228 struct
229 {
230 uint8_t cbOp;
231 /** BS3CG1OPLOC_XXX. */
232 uint8_t enmLocation;
233 /** BS3CG1OPLOC_XXX for memory encodings (MODRM.rm field). */
234 uint8_t enmLocationMem : 4;
235 /** BS3CG1OPLOC_XXX for register encodings (MODRM.rm field). */
236 uint8_t enmLocationReg : 4;
237 /** The BS3CG1DST value for this field.
238 * Set to BS3CG1DST_INVALID if memory or immediate. */
239 uint8_t idxField;
240 /** The base BS3CG1DST value for this field.
241 * Used only by some generalized encoders when dealing with registers. */
242 uint8_t idxFieldBase;
243 /** Depends on enmLocation.
244 * - BS3CG1OPLOC_IMM: offset relative to start of the instruction.
245 * - BS3CG1OPLOC_MEM: offset should be subtracted from &pbDataPg[_4K].
246 * - BS3CG1OPLOC_MEM_RW: offset should be subtracted from &pbDataPg[_4K].
247 * - BS3CG1OPLOC_MEM_RO: offset should be subtracted from &pbDataPg[_4K].
248 * - BS3CG1OPLOC_CTX: not used (use idxField instead).
249 */
250 uint8_t off;
251 } aOperands[4];
252 /** @} */
253
254 /** Page to put code in. When paging is enabled, the page before and after
255 * are marked not-present. */
256 uint8_t BS3_FAR *pbCodePg;
257 /** The flat address corresponding to pbCodePg. */
258 uintptr_t uCodePgFlat;
259 /** The 16-bit address corresponding to pbCodePg if relevant for bMode. */
260 RTFAR16 CodePgFar;
261 /** The IP/EIP/RIP value for pbCodePg[0] relative to CS (bMode). */
262 uintptr_t CodePgRip;
263
264 /** Page for placing data operands in. When paging is enabled, the page before
265 * and after are marked not-present. */
266 uint8_t BS3_FAR *pbDataPg;
267 /** The flat address corresponding to pbDataPg. */
268 uintptr_t uDataPgFlat;
269 /** The 16-bit address corresponding to pbDataPg. */
270 RTFAR16 DataPgFar;
271
272 /** The name corresponding to bMode. */
273 const char BS3_FAR *pszMode;
274 /** The short name corresponding to bMode. */
275 const char BS3_FAR *pszModeShort;
276
277 /** @name Expected result (modifiable by output program).
278 * @{ */
279 /** The expected exception based on operand values or result.
280 * UINT8_MAX if no special exception expected. */
281 uint8_t bValueXcpt;
282 /** @} */
283 /** Alignment exception expected by the encoder.
284 * UINT8_MAX if no special exception expected. */
285 uint8_t bAlignmentXcpt;
286 /** Set by the encoding method to indicating invalid encoding. */
287 bool fInvalidEncoding;
288 /** The result of Bs3Cg1CpuSetupFirst(). */
289 bool fCpuSetupFirstResult;
290
291 /** The context we're working on. */
292 BS3REGCTX Ctx;
293 /** The trap context and frame. */
294 BS3TRAPFRAME TrapFrame;
295 /** Initial contexts, one for each ring. */
296 BS3REGCTX aInitialCtxs[4];
297
298 /** The extended context we're working on (input, expected output). */
299 PBS3EXTCTX pExtCtx;
300 /** The extended result context (analoguous to TrapFrame). */
301 PBS3EXTCTX pResultExtCtx;
302 /** The initial extended context. */
303 PBS3EXTCTX pInitialExtCtx;
304
305 /** Memory operand scratch space. */
306 union
307 {
308 uint8_t ab[128];
309 uint16_t au16[128 / sizeof(uint16_t)];
310 uint32_t au32[128 / sizeof(uint32_t)];
311 uint64_t au64[128 / sizeof(uint64_t)];
312 } MemOp;
313
314 /** Array parallel to aInitialCtxs for saving segment registers. */
315 struct
316 {
317 RTSEL ds;
318 } aSavedSegRegs[4];
319
320} BS3CG1STATE;
321
322
323#define BS3CG1_PF_OZ UINT16_C(0x0001)
324#define BS3CG1_PF_AZ UINT16_C(0x0002)
325#define BS3CG1_PF_CS UINT16_C(0x0004)
326#define BS3CG1_PF_DS UINT16_C(0x0008)
327#define BS3CG1_PF_ES UINT16_C(0x0010)
328#define BS3CG1_PF_FS UINT16_C(0x0020)
329#define BS3CG1_PF_GS UINT16_C(0x0040)
330#define BS3CG1_PF_SS UINT16_C(0x0080)
331#define BS3CG1_PF_SEGS (BS3CG1_PF_CS | BS3CG1_PF_DS | BS3CG1_PF_ES | BS3CG1_PF_FS | BS3CG1_PF_GS | BS3CG1_PF_SS)
332#define BS3CG1_PF_MEM (BS3CG1_PF_SEGS | BS3CG1_PF_AZ)
333#define BS3CG1_PF_LK UINT16_C(0x0100)
334#define BS3CG1_PF_RN UINT16_C(0x0200)
335#define BS3CG1_PF_RZ UINT16_C(0x0400)
336#define BS3CG1_PF_W UINT16_C(0x0800) /**< REX.W */
337#define BS3CG1_PF_R UINT16_C(0x1000) /**< REX.R */
338#define BS3CG1_PF_B UINT16_C(0x2000) /**< REX.B */
339#define BS3CG1_PF_X UINT16_C(0x4000) /**< REX.X */
340
341
342/** Used in g_cbBs3Cg1DstFields to indicate that it's one of the 4 operands. */
343#define BS3CG1DSTSIZE_OPERAND UINT8_C(255)
344/** Used in g_cbBs3Cg1DstFields to indicate that the operand size determins
345 * the field size (2, 4, or 8). */
346#define BS3CG1DSTSIZE_OPERAND_SIZE_GRP UINT8_C(254)
347
348
349
350/*********************************************************************************************************************************
351* Global Variables *
352*********************************************************************************************************************************/
353/** Destination field sizes indexed by bBS3CG1DST.
354 * Zero means operand size sized. */
355static const uint8_t g_acbBs3Cg1DstFields[] =
356{
357 /* [BS3CG1DST_INVALID] = */ BS3CG1DSTSIZE_OPERAND,
358
359 /* [BS3CG1DST_OP1] = */ BS3CG1DSTSIZE_OPERAND,
360 /* [BS3CG1DST_OP2] = */ BS3CG1DSTSIZE_OPERAND,
361 /* [BS3CG1DST_OP3] = */ BS3CG1DSTSIZE_OPERAND,
362 /* [BS3CG1DST_OP4] = */ BS3CG1DSTSIZE_OPERAND,
363 /* [BS3CG1DST_EFL] = */ 4,
364 /* [BS3CG1DST_EFL_UNDEF]=*/ 4,
365
366 /* [BS3CG1DST_AL] = */ 1,
367 /* [BS3CG1DST_CL] = */ 1,
368 /* [BS3CG1DST_DL] = */ 1,
369 /* [BS3CG1DST_BL] = */ 1,
370 /* [BS3CG1DST_AH] = */ 1,
371 /* [BS3CG1DST_CH] = */ 1,
372 /* [BS3CG1DST_DH] = */ 1,
373 /* [BS3CG1DST_BH] = */ 1,
374 /* [BS3CG1DST_SPL] = */ 1,
375 /* [BS3CG1DST_BPL] = */ 1,
376 /* [BS3CG1DST_SIL] = */ 1,
377 /* [BS3CG1DST_DIL] = */ 1,
378 /* [BS3CG1DST_R8L] = */ 1,
379 /* [BS3CG1DST_R9L] = */ 1,
380 /* [BS3CG1DST_R10L] = */ 1,
381 /* [BS3CG1DST_R11L] = */ 1,
382 /* [BS3CG1DST_R12L] = */ 1,
383 /* [BS3CG1DST_R13L] = */ 1,
384 /* [BS3CG1DST_R14L] = */ 1,
385 /* [BS3CG1DST_R15L] = */ 1,
386
387 /* [BS3CG1DST_AX] = */ 2,
388 /* [BS3CG1DST_CX] = */ 2,
389 /* [BS3CG1DST_DX] = */ 2,
390 /* [BS3CG1DST_BX] = */ 2,
391 /* [BS3CG1DST_SP] = */ 2,
392 /* [BS3CG1DST_BP] = */ 2,
393 /* [BS3CG1DST_SI] = */ 2,
394 /* [BS3CG1DST_DI] = */ 2,
395 /* [BS3CG1DST_R8W] = */ 2,
396 /* [BS3CG1DST_R9W] = */ 2,
397 /* [BS3CG1DST_R10W] = */ 2,
398 /* [BS3CG1DST_R11W] = */ 2,
399 /* [BS3CG1DST_R12W] = */ 2,
400 /* [BS3CG1DST_R13W] = */ 2,
401 /* [BS3CG1DST_R14W] = */ 2,
402 /* [BS3CG1DST_R15W] = */ 2,
403
404 /* [BS3CG1DST_EAX] = */ 4,
405 /* [BS3CG1DST_ECX] = */ 4,
406 /* [BS3CG1DST_EDX] = */ 4,
407 /* [BS3CG1DST_EBX] = */ 4,
408 /* [BS3CG1DST_ESP] = */ 4,
409 /* [BS3CG1DST_EBP] = */ 4,
410 /* [BS3CG1DST_ESI] = */ 4,
411 /* [BS3CG1DST_EDI] = */ 4,
412 /* [BS3CG1DST_R8D] = */ 4,
413 /* [BS3CG1DST_R9D] = */ 4,
414 /* [BS3CG1DST_R10D] = */ 4,
415 /* [BS3CG1DST_R11D] = */ 4,
416 /* [BS3CG1DST_R12D] = */ 4,
417 /* [BS3CG1DST_R13D] = */ 4,
418 /* [BS3CG1DST_R14D] = */ 4,
419 /* [BS3CG1DST_R15D] = */ 4,
420
421 /* [BS3CG1DST_RAX] = */ 8,
422 /* [BS3CG1DST_RCX] = */ 8,
423 /* [BS3CG1DST_RDX] = */ 8,
424 /* [BS3CG1DST_RBX] = */ 8,
425 /* [BS3CG1DST_RSP] = */ 8,
426 /* [BS3CG1DST_RBP] = */ 8,
427 /* [BS3CG1DST_RSI] = */ 8,
428 /* [BS3CG1DST_RDI] = */ 8,
429 /* [BS3CG1DST_R8] = */ 8,
430 /* [BS3CG1DST_R9] = */ 8,
431 /* [BS3CG1DST_R10] = */ 8,
432 /* [BS3CG1DST_R11] = */ 8,
433 /* [BS3CG1DST_R12] = */ 8,
434 /* [BS3CG1DST_R13] = */ 8,
435 /* [BS3CG1DST_R14] = */ 8,
436 /* [BS3CG1DST_R15] = */ 8,
437
438 /* [BS3CG1DST_OZ_RAX] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
439 /* [BS3CG1DST_OZ_RCX] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
440 /* [BS3CG1DST_OZ_RDX] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
441 /* [BS3CG1DST_OZ_RBX] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
442 /* [BS3CG1DST_OZ_RSP] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
443 /* [BS3CG1DST_OZ_RBP] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
444 /* [BS3CG1DST_OZ_RSI] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
445 /* [BS3CG1DST_OZ_RDI] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
446 /* [BS3CG1DST_OZ_R8] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
447 /* [BS3CG1DST_OZ_R9] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
448 /* [BS3CG1DST_OZ_R10] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
449 /* [BS3CG1DST_OZ_R11] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
450 /* [BS3CG1DST_OZ_R12] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
451 /* [BS3CG1DST_OZ_R13] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
452 /* [BS3CG1DST_OZ_R14] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
453 /* [BS3CG1DST_OZ_R15] = */ BS3CG1DSTSIZE_OPERAND_SIZE_GRP,
454
455 /* [BS3CG1DST_CR0] = */ 4,
456 /* [BS3CG1DST_CR4] = */ 4,
457 /* [BS3CG1DST_XCR0] = */ 8,
458
459 /* [BS3CG1DST_FCW] = */ 2,
460 /* [BS3CG1DST_FSW] = */ 2,
461 /* [BS3CG1DST_FTW] = */ 2,
462 /* [BS3CG1DST_FOP] = */ 2,
463 /* [BS3CG1DST_FPUIP] = */ 2,
464 /* [BS3CG1DST_FPUCS] = */ 2,
465 /* [BS3CG1DST_FPUDP] = */ 2,
466 /* [BS3CG1DST_FPUDS] = */ 2,
467 /* [BS3CG1DST_MXCSR] = */ 4,
468 /* [BS3CG1DST_ST0] = */ 12,
469 /* [BS3CG1DST_ST1] = */ 12,
470 /* [BS3CG1DST_ST2] = */ 12,
471 /* [BS3CG1DST_ST3] = */ 12,
472 /* [BS3CG1DST_ST4] = */ 12,
473 /* [BS3CG1DST_ST5] = */ 12,
474 /* [BS3CG1DST_ST6] = */ 12,
475 /* [BS3CG1DST_ST7] = */ 12,
476 /* [BS3CG1DST_MM0] = */ 8,
477 /* [BS3CG1DST_MM1] = */ 8,
478 /* [BS3CG1DST_MM2] = */ 8,
479 /* [BS3CG1DST_MM3] = */ 8,
480 /* [BS3CG1DST_MM4] = */ 8,
481 /* [BS3CG1DST_MM5] = */ 8,
482 /* [BS3CG1DST_MM6] = */ 8,
483 /* [BS3CG1DST_MM7] = */ 8,
484 /* [BS3CG1DST_MM0_LO_ZX] = */ 4,
485 /* [BS3CG1DST_MM1_LO_ZX] = */ 4,
486 /* [BS3CG1DST_MM2_LO_ZX] = */ 4,
487 /* [BS3CG1DST_MM3_LO_ZX] = */ 4,
488 /* [BS3CG1DST_MM4_LO_ZX] = */ 4,
489 /* [BS3CG1DST_MM5_LO_ZX] = */ 4,
490 /* [BS3CG1DST_MM6_LO_ZX] = */ 4,
491 /* [BS3CG1DST_MM7_LO_ZX] = */ 4,
492 /* [BS3CG1DST_XMM0] = */ 16,
493 /* [BS3CG1DST_XMM1] = */ 16,
494 /* [BS3CG1DST_XMM2] = */ 16,
495 /* [BS3CG1DST_XMM3] = */ 16,
496 /* [BS3CG1DST_XMM4] = */ 16,
497 /* [BS3CG1DST_XMM5] = */ 16,
498 /* [BS3CG1DST_XMM6] = */ 16,
499 /* [BS3CG1DST_XMM7] = */ 16,
500 /* [BS3CG1DST_XMM8] = */ 16,
501 /* [BS3CG1DST_XMM9] = */ 16,
502 /* [BS3CG1DST_XMM10] = */ 16,
503 /* [BS3CG1DST_XMM11] = */ 16,
504 /* [BS3CG1DST_XMM12] = */ 16,
505 /* [BS3CG1DST_XMM13] = */ 16,
506 /* [BS3CG1DST_XMM14] = */ 16,
507 /* [BS3CG1DST_XMM15] = */ 16,
508 /* [BS3CG1DST_XMM0_LO] = */ 8,
509 /* [BS3CG1DST_XMM1_LO] = */ 8,
510 /* [BS3CG1DST_XMM2_LO] = */ 8,
511 /* [BS3CG1DST_XMM3_LO] = */ 8,
512 /* [BS3CG1DST_XMM4_LO] = */ 8,
513 /* [BS3CG1DST_XMM5_LO] = */ 8,
514 /* [BS3CG1DST_XMM6_LO] = */ 8,
515 /* [BS3CG1DST_XMM7_LO] = */ 8,
516 /* [BS3CG1DST_XMM8_LO] = */ 8,
517 /* [BS3CG1DST_XMM9_LO] = */ 8,
518 /* [BS3CG1DST_XMM10_LO] = */ 8,
519 /* [BS3CG1DST_XMM11_LO] = */ 8,
520 /* [BS3CG1DST_XMM12_LO] = */ 8,
521 /* [BS3CG1DST_XMM13_LO] = */ 8,
522 /* [BS3CG1DST_XMM14_LO] = */ 8,
523 /* [BS3CG1DST_XMM15_LO] = */ 8,
524 /* [BS3CG1DST_XMM0_HI] = */ 8,
525 /* [BS3CG1DST_XMM1_HI] = */ 8,
526 /* [BS3CG1DST_XMM2_HI] = */ 8,
527 /* [BS3CG1DST_XMM3_HI] = */ 8,
528 /* [BS3CG1DST_XMM4_HI] = */ 8,
529 /* [BS3CG1DST_XMM5_HI] = */ 8,
530 /* [BS3CG1DST_XMM6_HI] = */ 8,
531 /* [BS3CG1DST_XMM7_HI] = */ 8,
532 /* [BS3CG1DST_XMM8_HI] = */ 8,
533 /* [BS3CG1DST_XMM9_HI] = */ 8,
534 /* [BS3CG1DST_XMM10_HI] = */ 8,
535 /* [BS3CG1DST_XMM11_HI] = */ 8,
536 /* [BS3CG1DST_XMM12_HI] = */ 8,
537 /* [BS3CG1DST_XMM13_HI] = */ 8,
538 /* [BS3CG1DST_XMM14_HI] = */ 8,
539 /* [BS3CG1DST_XMM15_HI] = */ 8,
540 /* [BS3CG1DST_XMM0_LO_ZX] = */ 8,
541 /* [BS3CG1DST_XMM1_LO_ZX] = */ 8,
542 /* [BS3CG1DST_XMM2_LO_ZX] = */ 8,
543 /* [BS3CG1DST_XMM3_LO_ZX] = */ 8,
544 /* [BS3CG1DST_XMM4_LO_ZX] = */ 8,
545 /* [BS3CG1DST_XMM5_LO_ZX] = */ 8,
546 /* [BS3CG1DST_XMM6_LO_ZX] = */ 8,
547 /* [BS3CG1DST_XMM7_LO_ZX] = */ 8,
548 /* [BS3CG1DST_XMM8_LO_ZX] = */ 8,
549 /* [BS3CG1DST_XMM9_LO_ZX] = */ 8,
550 /* [BS3CG1DST_XMM10_LO_ZX] = */ 8,
551 /* [BS3CG1DST_XMM11_LO_ZX] = */ 8,
552 /* [BS3CG1DST_XMM12_LO_ZX] = */ 8,
553 /* [BS3CG1DST_XMM13_LO_ZX] = */ 8,
554 /* [BS3CG1DST_XMM14_LO_ZX] = */ 8,
555 /* [BS3CG1DST_XMM15_LO_ZX] = */ 8,
556 /* [BS3CG1DST_XMM0_DW0] = */ 4,
557 /* [BS3CG1DST_XMM1_DW0] = */ 4,
558 /* [BS3CG1DST_XMM2_DW0] = */ 4,
559 /* [BS3CG1DST_XMM3_DW0] = */ 4,
560 /* [BS3CG1DST_XMM4_DW0] = */ 4,
561 /* [BS3CG1DST_XMM5_DW0] = */ 4,
562 /* [BS3CG1DST_XMM6_DW0] = */ 4,
563 /* [BS3CG1DST_XMM7_DW0] = */ 4,
564 /* [BS3CG1DST_XMM8_DW0] = */ 4,
565 /* [BS3CG1DST_XMM9_DW0] = */ 4,
566 /* [BS3CG1DST_XMM10_DW0] = */ 4,
567 /* [BS3CG1DST_XMM11_DW0] = */ 4,
568 /* [BS3CG1DST_XMM12_DW0] = */ 4,
569 /* [BS3CG1DST_XMM13_DW0] = */ 4,
570 /* [BS3CG1DST_XMM14_DW0] = */ 4,
571 /* [BS3CG1DST_XMM15_DW0] = */ 4,
572 /* [BS3CG1DST_XMM0_DW0_ZX] = */ 4,
573 /* [BS3CG1DST_XMM1_DW0_ZX] = */ 4,
574 /* [BS3CG1DST_XMM2_DW0_ZX] = */ 4,
575 /* [BS3CG1DST_XMM3_DW0_ZX] = */ 4,
576 /* [BS3CG1DST_XMM4_DW0_ZX] = */ 4,
577 /* [BS3CG1DST_XMM5_DW0_ZX] = */ 4,
578 /* [BS3CG1DST_XMM6_DW0_ZX] = */ 4,
579 /* [BS3CG1DST_XMM7_DW0_ZX] = */ 4,
580 /* [BS3CG1DST_XMM8_DW0_ZX] = */ 4,
581 /* [BS3CG1DST_XMM9_DW0_ZX] = */ 4,
582 /* [BS3CG1DST_XMM10_DW0_ZX] =*/ 4,
583 /* [BS3CG1DST_XMM11_DW0_ZX] =*/ 4,
584 /* [BS3CG1DST_XMM12_DW0_ZX] =*/ 4,
585 /* [BS3CG1DST_XMM13_DW0_ZX] =*/ 4,
586 /* [BS3CG1DST_XMM14_DW0_ZX] =*/ 4,
587 /* [BS3CG1DST_XMM15_DW0_ZX] =*/ 4,
588 /* [BS3CG1DST_XMM0_HI96] = */ 12,
589 /* [BS3CG1DST_XMM1_HI96] = */ 12,
590 /* [BS3CG1DST_XMM2_HI96] = */ 12,
591 /* [BS3CG1DST_XMM3_HI96] = */ 12,
592 /* [BS3CG1DST_XMM4_HI96] = */ 12,
593 /* [BS3CG1DST_XMM5_HI96] = */ 12,
594 /* [BS3CG1DST_XMM6_HI96] = */ 12,
595 /* [BS3CG1DST_XMM7_HI96] = */ 12,
596 /* [BS3CG1DST_XMM8_HI96] = */ 12,
597 /* [BS3CG1DST_XMM9_HI96] = */ 12,
598 /* [BS3CG1DST_XMM10_HI96] =*/ 12,
599 /* [BS3CG1DST_XMM11_HI96] =*/ 12,
600 /* [BS3CG1DST_XMM12_HI96] =*/ 12,
601 /* [BS3CG1DST_XMM13_HI96] =*/ 12,
602 /* [BS3CG1DST_XMM14_HI96] =*/ 12,
603 /* [BS3CG1DST_XMM15_HI96] =*/ 12,
604 /* [BS3CG1DST_YMM0] = */ 32,
605 /* [BS3CG1DST_YMM1] = */ 32,
606 /* [BS3CG1DST_YMM2] = */ 32,
607 /* [BS3CG1DST_YMM3] = */ 32,
608 /* [BS3CG1DST_YMM4] = */ 32,
609 /* [BS3CG1DST_YMM5] = */ 32,
610 /* [BS3CG1DST_YMM6] = */ 32,
611 /* [BS3CG1DST_YMM7] = */ 32,
612 /* [BS3CG1DST_YMM8] = */ 32,
613 /* [BS3CG1DST_YMM9] = */ 32,
614 /* [BS3CG1DST_YMM10] = */ 32,
615 /* [BS3CG1DST_YMM11] = */ 32,
616 /* [BS3CG1DST_YMM12] = */ 32,
617 /* [BS3CG1DST_YMM13] = */ 32,
618 /* [BS3CG1DST_YMM14] = */ 32,
619 /* [BS3CG1DST_YMM15] = */ 32,
620
621 /* [BS3CG1DST_VALUE_XCPT] = */ 1,
622};
623AssertCompile(RT_ELEMENTS(g_acbBs3Cg1DstFields) == BS3CG1DST_END);
624
625/** Destination field offset indexed by bBS3CG1DST.
626 * Zero means operand size sized. */
627static const unsigned g_aoffBs3Cg1DstFields[] =
628{
629 /* [BS3CG1DST_INVALID] = */ ~0U,
630 /* [BS3CG1DST_OP1] = */ ~0U,
631 /* [BS3CG1DST_OP2] = */ ~0U,
632 /* [BS3CG1DST_OP3] = */ ~0U,
633 /* [BS3CG1DST_OP4] = */ ~0U,
634 /* [BS3CG1DST_EFL] = */ RT_OFFSETOF(BS3REGCTX, rflags),
635 /* [BS3CG1DST_EFL_UNDEF]=*/ ~0, /* special field */
636
637 /* [BS3CG1DST_AL] = */ RT_OFFSETOF(BS3REGCTX, rax.u8),
638 /* [BS3CG1DST_CL] = */ RT_OFFSETOF(BS3REGCTX, rcx.u8),
639 /* [BS3CG1DST_DL] = */ RT_OFFSETOF(BS3REGCTX, rdx.u8),
640 /* [BS3CG1DST_BL] = */ RT_OFFSETOF(BS3REGCTX, rbx.u8),
641 /* [BS3CG1DST_AH] = */ RT_OFFSETOF(BS3REGCTX, rax.b.bHi),
642 /* [BS3CG1DST_CH] = */ RT_OFFSETOF(BS3REGCTX, rcx.b.bHi),
643 /* [BS3CG1DST_DH] = */ RT_OFFSETOF(BS3REGCTX, rdx.b.bHi),
644 /* [BS3CG1DST_BH] = */ RT_OFFSETOF(BS3REGCTX, rbx.b.bHi),
645 /* [BS3CG1DST_SPL] = */ RT_OFFSETOF(BS3REGCTX, rsp.u8),
646 /* [BS3CG1DST_BPL] = */ RT_OFFSETOF(BS3REGCTX, rbp.u8),
647 /* [BS3CG1DST_SIL] = */ RT_OFFSETOF(BS3REGCTX, rsi.u8),
648 /* [BS3CG1DST_DIL] = */ RT_OFFSETOF(BS3REGCTX, rdi.u8),
649 /* [BS3CG1DST_R8L] = */ RT_OFFSETOF(BS3REGCTX, r8.u8),
650 /* [BS3CG1DST_R9L] = */ RT_OFFSETOF(BS3REGCTX, r9.u8),
651 /* [BS3CG1DST_R10L] = */ RT_OFFSETOF(BS3REGCTX, r10.u8),
652 /* [BS3CG1DST_R11L] = */ RT_OFFSETOF(BS3REGCTX, r11.u8),
653 /* [BS3CG1DST_R12L] = */ RT_OFFSETOF(BS3REGCTX, r12.u8),
654 /* [BS3CG1DST_R13L] = */ RT_OFFSETOF(BS3REGCTX, r13.u8),
655 /* [BS3CG1DST_R14L] = */ RT_OFFSETOF(BS3REGCTX, r14.u8),
656 /* [BS3CG1DST_R15L] = */ RT_OFFSETOF(BS3REGCTX, r15.u8),
657
658 /* [BS3CG1DST_AX] = */ RT_OFFSETOF(BS3REGCTX, rax.u16),
659 /* [BS3CG1DST_CX] = */ RT_OFFSETOF(BS3REGCTX, rcx.u16),
660 /* [BS3CG1DST_DX] = */ RT_OFFSETOF(BS3REGCTX, rdx.u16),
661 /* [BS3CG1DST_BX] = */ RT_OFFSETOF(BS3REGCTX, rbx.u16),
662 /* [BS3CG1DST_SP] = */ RT_OFFSETOF(BS3REGCTX, rsp.u16),
663 /* [BS3CG1DST_BP] = */ RT_OFFSETOF(BS3REGCTX, rbp.u16),
664 /* [BS3CG1DST_SI] = */ RT_OFFSETOF(BS3REGCTX, rsi.u16),
665 /* [BS3CG1DST_DI] = */ RT_OFFSETOF(BS3REGCTX, rdi.u16),
666 /* [BS3CG1DST_R8W] = */ RT_OFFSETOF(BS3REGCTX, r8.u16),
667 /* [BS3CG1DST_R9W] = */ RT_OFFSETOF(BS3REGCTX, r9.u16),
668 /* [BS3CG1DST_R10W] = */ RT_OFFSETOF(BS3REGCTX, r10.u16),
669 /* [BS3CG1DST_R11W] = */ RT_OFFSETOF(BS3REGCTX, r11.u16),
670 /* [BS3CG1DST_R12W] = */ RT_OFFSETOF(BS3REGCTX, r12.u16),
671 /* [BS3CG1DST_R13W] = */ RT_OFFSETOF(BS3REGCTX, r13.u16),
672 /* [BS3CG1DST_R14W] = */ RT_OFFSETOF(BS3REGCTX, r14.u16),
673 /* [BS3CG1DST_R15W] = */ RT_OFFSETOF(BS3REGCTX, r15.u16),
674
675 /* [BS3CG1DST_EAX] = */ RT_OFFSETOF(BS3REGCTX, rax.u32),
676 /* [BS3CG1DST_ECX] = */ RT_OFFSETOF(BS3REGCTX, rcx.u32),
677 /* [BS3CG1DST_EDX] = */ RT_OFFSETOF(BS3REGCTX, rdx.u32),
678 /* [BS3CG1DST_EBX] = */ RT_OFFSETOF(BS3REGCTX, rbx.u32),
679 /* [BS3CG1DST_ESP] = */ RT_OFFSETOF(BS3REGCTX, rsp.u32),
680 /* [BS3CG1DST_EBP] = */ RT_OFFSETOF(BS3REGCTX, rbp.u32),
681 /* [BS3CG1DST_ESI] = */ RT_OFFSETOF(BS3REGCTX, rsi.u32),
682 /* [BS3CG1DST_EDI] = */ RT_OFFSETOF(BS3REGCTX, rdi.u32),
683 /* [BS3CG1DST_R8D] = */ RT_OFFSETOF(BS3REGCTX, r8.u32),
684 /* [BS3CG1DST_R9D] = */ RT_OFFSETOF(BS3REGCTX, r9.u32),
685 /* [BS3CG1DST_R10D] = */ RT_OFFSETOF(BS3REGCTX, r10.u32),
686 /* [BS3CG1DST_R11D] = */ RT_OFFSETOF(BS3REGCTX, r11.u32),
687 /* [BS3CG1DST_R12D] = */ RT_OFFSETOF(BS3REGCTX, r12.u32),
688 /* [BS3CG1DST_R13D] = */ RT_OFFSETOF(BS3REGCTX, r13.u32),
689 /* [BS3CG1DST_R14D] = */ RT_OFFSETOF(BS3REGCTX, r14.u32),
690 /* [BS3CG1DST_R15D] = */ RT_OFFSETOF(BS3REGCTX, r15.u32),
691
692 /* [BS3CG1DST_RAX] = */ RT_OFFSETOF(BS3REGCTX, rax.u64),
693 /* [BS3CG1DST_RCX] = */ RT_OFFSETOF(BS3REGCTX, rcx.u64),
694 /* [BS3CG1DST_RDX] = */ RT_OFFSETOF(BS3REGCTX, rdx.u64),
695 /* [BS3CG1DST_RBX] = */ RT_OFFSETOF(BS3REGCTX, rbx.u64),
696 /* [BS3CG1DST_RSP] = */ RT_OFFSETOF(BS3REGCTX, rsp.u64),
697 /* [BS3CG1DST_RBP] = */ RT_OFFSETOF(BS3REGCTX, rbp.u64),
698 /* [BS3CG1DST_RSI] = */ RT_OFFSETOF(BS3REGCTX, rsi.u64),
699 /* [BS3CG1DST_RDI] = */ RT_OFFSETOF(BS3REGCTX, rdi.u64),
700 /* [BS3CG1DST_R8] = */ RT_OFFSETOF(BS3REGCTX, r8.u64),
701 /* [BS3CG1DST_R9] = */ RT_OFFSETOF(BS3REGCTX, r9.u64),
702 /* [BS3CG1DST_R10] = */ RT_OFFSETOF(BS3REGCTX, r10.u64),
703 /* [BS3CG1DST_R11] = */ RT_OFFSETOF(BS3REGCTX, r11.u64),
704 /* [BS3CG1DST_R12] = */ RT_OFFSETOF(BS3REGCTX, r12.u64),
705 /* [BS3CG1DST_R13] = */ RT_OFFSETOF(BS3REGCTX, r13.u64),
706 /* [BS3CG1DST_R14] = */ RT_OFFSETOF(BS3REGCTX, r14.u64),
707 /* [BS3CG1DST_R15] = */ RT_OFFSETOF(BS3REGCTX, r15.u64),
708
709 /* [BS3CG1DST_OZ_RAX] = */ RT_OFFSETOF(BS3REGCTX, rax),
710 /* [BS3CG1DST_OZ_RCX] = */ RT_OFFSETOF(BS3REGCTX, rcx),
711 /* [BS3CG1DST_OZ_RDX] = */ RT_OFFSETOF(BS3REGCTX, rdx),
712 /* [BS3CG1DST_OZ_RBX] = */ RT_OFFSETOF(BS3REGCTX, rbx),
713 /* [BS3CG1DST_OZ_RSP] = */ RT_OFFSETOF(BS3REGCTX, rsp),
714 /* [BS3CG1DST_OZ_RBP] = */ RT_OFFSETOF(BS3REGCTX, rbp),
715 /* [BS3CG1DST_OZ_RSI] = */ RT_OFFSETOF(BS3REGCTX, rsi),
716 /* [BS3CG1DST_OZ_RDI] = */ RT_OFFSETOF(BS3REGCTX, rdi),
717 /* [BS3CG1DST_OZ_R8] = */ RT_OFFSETOF(BS3REGCTX, r8),
718 /* [BS3CG1DST_OZ_R9] = */ RT_OFFSETOF(BS3REGCTX, r9),
719 /* [BS3CG1DST_OZ_R10] = */ RT_OFFSETOF(BS3REGCTX, r10),
720 /* [BS3CG1DST_OZ_R11] = */ RT_OFFSETOF(BS3REGCTX, r11),
721 /* [BS3CG1DST_OZ_R12] = */ RT_OFFSETOF(BS3REGCTX, r12),
722 /* [BS3CG1DST_OZ_R13] = */ RT_OFFSETOF(BS3REGCTX, r13),
723 /* [BS3CG1DST_OZ_R14] = */ RT_OFFSETOF(BS3REGCTX, r14),
724 /* [BS3CG1DST_OZ_R15] = */ RT_OFFSETOF(BS3REGCTX, r15),
725
726 /* [BS3CG1DST_CR0] = */ RT_OFFSETOF(BS3REGCTX, cr0),
727 /* [BS3CG1DST_CR4] = */ RT_OFFSETOF(BS3REGCTX, cr4),
728 /* [BS3CG1DST_XCR0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, fXcr0Saved),
729
730 /* [BS3CG1DST_FCW] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FCW),
731 /* [BS3CG1DST_FSW] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FSW),
732 /* [BS3CG1DST_FTW] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FTW),
733 /* [BS3CG1DST_FOP] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FOP),
734 /* [BS3CG1DST_FPUIP] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FPUIP),
735 /* [BS3CG1DST_FPUCS] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.CS),
736 /* [BS3CG1DST_FPUDP] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.FPUDP),
737 /* [BS3CG1DST_FPUDS] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.DS),
738 /* [BS3CG1DST_MXCSR] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.MXCSR),
739 /* [BS3CG1DST_ST0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[0]),
740 /* [BS3CG1DST_ST1] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[1]),
741 /* [BS3CG1DST_ST2] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[2]),
742 /* [BS3CG1DST_ST3] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[3]),
743 /* [BS3CG1DST_ST4] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[4]),
744 /* [BS3CG1DST_ST5] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[5]),
745 /* [BS3CG1DST_ST6] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[6]),
746 /* [BS3CG1DST_ST7] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[7]),
747 /* [BS3CG1DST_MM0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[0]),
748 /* [BS3CG1DST_MM1] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[1]),
749 /* [BS3CG1DST_MM2] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[2]),
750 /* [BS3CG1DST_MM3] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[3]),
751 /* [BS3CG1DST_MM4] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[4]),
752 /* [BS3CG1DST_MM5] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[5]),
753 /* [BS3CG1DST_MM6] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[6]),
754 /* [BS3CG1DST_MM7] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[7]),
755 /* [BS3CG1DST_MM0_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[0]),
756 /* [BS3CG1DST_MM1_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[1]),
757 /* [BS3CG1DST_MM2_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[2]),
758 /* [BS3CG1DST_MM3_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[3]),
759 /* [BS3CG1DST_MM4_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[4]),
760 /* [BS3CG1DST_MM5_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[5]),
761 /* [BS3CG1DST_MM6_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[6]),
762 /* [BS3CG1DST_MM7_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aRegs[7]),
763
764 /* [BS3CG1DST_XMM0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
765 /* [BS3CG1DST_XMM1] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]),
766 /* [BS3CG1DST_XMM2] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]),
767 /* [BS3CG1DST_XMM3] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]),
768 /* [BS3CG1DST_XMM4] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]),
769 /* [BS3CG1DST_XMM5] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]),
770 /* [BS3CG1DST_XMM6] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]),
771 /* [BS3CG1DST_XMM7] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]),
772 /* [BS3CG1DST_XMM8] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]),
773 /* [BS3CG1DST_XMM9] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]),
774 /* [BS3CG1DST_XMM10] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]),
775 /* [BS3CG1DST_XMM11] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]),
776 /* [BS3CG1DST_XMM12] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]),
777 /* [BS3CG1DST_XMM13] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]),
778 /* [BS3CG1DST_XMM14] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]),
779 /* [BS3CG1DST_XMM15] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]),
780 /* [BS3CG1DST_XMM0_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
781 /* [BS3CG1DST_XMM1_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]),
782 /* [BS3CG1DST_XMM2_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]),
783 /* [BS3CG1DST_XMM3_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]),
784 /* [BS3CG1DST_XMM4_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]),
785 /* [BS3CG1DST_XMM5_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]),
786 /* [BS3CG1DST_XMM6_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]),
787 /* [BS3CG1DST_XMM7_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]),
788 /* [BS3CG1DST_XMM8_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]),
789 /* [BS3CG1DST_XMM9_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]),
790 /* [BS3CG1DST_XMM10_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]),
791 /* [BS3CG1DST_XMM11_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]),
792 /* [BS3CG1DST_XMM12_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]),
793 /* [BS3CG1DST_XMM13_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]),
794 /* [BS3CG1DST_XMM14_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]),
795 /* [BS3CG1DST_XMM15_LO] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]),
796 /* [BS3CG1DST_XMM0_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]) + sizeof(uint64_t),
797 /* [BS3CG1DST_XMM1_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]) + sizeof(uint64_t),
798 /* [BS3CG1DST_XMM2_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]) + sizeof(uint64_t),
799 /* [BS3CG1DST_XMM3_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]) + sizeof(uint64_t),
800 /* [BS3CG1DST_XMM4_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]) + sizeof(uint64_t),
801 /* [BS3CG1DST_XMM5_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]) + sizeof(uint64_t),
802 /* [BS3CG1DST_XMM6_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]) + sizeof(uint64_t),
803 /* [BS3CG1DST_XMM7_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]) + sizeof(uint64_t),
804 /* [BS3CG1DST_XMM8_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]) + sizeof(uint64_t),
805 /* [BS3CG1DST_XMM9_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]) + sizeof(uint64_t),
806 /* [BS3CG1DST_XMM10_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]) + sizeof(uint64_t),
807 /* [BS3CG1DST_XMM11_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]) + sizeof(uint64_t),
808 /* [BS3CG1DST_XMM12_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]) + sizeof(uint64_t),
809 /* [BS3CG1DST_XMM13_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]) + sizeof(uint64_t),
810 /* [BS3CG1DST_XMM14_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]) + sizeof(uint64_t),
811 /* [BS3CG1DST_XMM15_HI] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]) + sizeof(uint64_t),
812 /* [BS3CG1DST_XMM0_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
813 /* [BS3CG1DST_XMM1_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]),
814 /* [BS3CG1DST_XMM2_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]),
815 /* [BS3CG1DST_XMM3_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]),
816 /* [BS3CG1DST_XMM4_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]),
817 /* [BS3CG1DST_XMM5_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]),
818 /* [BS3CG1DST_XMM6_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]),
819 /* [BS3CG1DST_XMM7_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]),
820 /* [BS3CG1DST_XMM8_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]),
821 /* [BS3CG1DST_XMM9_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]),
822 /* [BS3CG1DST_XMM10_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]),
823 /* [BS3CG1DST_XMM11_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]),
824 /* [BS3CG1DST_XMM12_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]),
825 /* [BS3CG1DST_XMM13_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]),
826 /* [BS3CG1DST_XMM14_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]),
827 /* [BS3CG1DST_XMM15_LO_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]),
828 /* [BS3CG1DST_XMM0_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
829 /* [BS3CG1DST_XMM1_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]),
830 /* [BS3CG1DST_XMM2_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]),
831 /* [BS3CG1DST_XMM3_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]),
832 /* [BS3CG1DST_XMM4_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]),
833 /* [BS3CG1DST_XMM5_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]),
834 /* [BS3CG1DST_XMM6_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]),
835 /* [BS3CG1DST_XMM7_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]),
836 /* [BS3CG1DST_XMM8_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]),
837 /* [BS3CG1DST_XMM9_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]),
838 /* [BS3CG1DST_XMM10_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]),
839 /* [BS3CG1DST_XMM11_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]),
840 /* [BS3CG1DST_XMM12_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]),
841 /* [BS3CG1DST_XMM13_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]),
842 /* [BS3CG1DST_XMM14_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]),
843 /* [BS3CG1DST_XMM15_DW0] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]),
844 /* [BS3CG1DST_XMM0_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0]),
845 /* [BS3CG1DST_XMM1_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1]),
846 /* [BS3CG1DST_XMM2_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2]),
847 /* [BS3CG1DST_XMM3_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3]),
848 /* [BS3CG1DST_XMM4_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4]),
849 /* [BS3CG1DST_XMM5_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5]),
850 /* [BS3CG1DST_XMM6_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6]),
851 /* [BS3CG1DST_XMM7_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7]),
852 /* [BS3CG1DST_XMM8_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8]),
853 /* [BS3CG1DST_XMM9_DW0_ZX] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9]),
854 /* [BS3CG1DST_XMM10_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10]),
855 /* [BS3CG1DST_XMM11_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11]),
856 /* [BS3CG1DST_XMM12_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12]),
857 /* [BS3CG1DST_XMM13_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13]),
858 /* [BS3CG1DST_XMM14_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14]),
859 /* [BS3CG1DST_XMM15_DW0_ZX] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15]),
860 /* [BS3CG1DST_XMM0_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[0].au32[1]),
861 /* [BS3CG1DST_XMM1_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[1].au32[1]),
862 /* [BS3CG1DST_XMM2_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[2].au32[1]),
863 /* [BS3CG1DST_XMM3_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[3].au32[1]),
864 /* [BS3CG1DST_XMM4_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[4].au32[1]),
865 /* [BS3CG1DST_XMM5_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[5].au32[1]),
866 /* [BS3CG1DST_XMM6_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[6].au32[1]),
867 /* [BS3CG1DST_XMM7_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[7].au32[1]),
868 /* [BS3CG1DST_XMM8_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[8].au32[1]),
869 /* [BS3CG1DST_XMM9_HI96] = */ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[9].au32[1]),
870 /* [BS3CG1DST_XMM10_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[10].au32[1]),
871 /* [BS3CG1DST_XMM11_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[11].au32[1]),
872 /* [BS3CG1DST_XMM12_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[12].au32[1]),
873 /* [BS3CG1DST_XMM13_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[13].au32[1]),
874 /* [BS3CG1DST_XMM14_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[14].au32[1]),
875 /* [BS3CG1DST_XMM15_HI96] =*/ sizeof(BS3REGCTX) + RT_OFFSETOF(BS3EXTCTX, Ctx.x87.aXMM[15].au32[1]),
876
877 /* [BS3CG1DST_YMM0] = */ ~0U,
878 /* [BS3CG1DST_YMM1] = */ ~0U,
879 /* [BS3CG1DST_YMM2] = */ ~0U,
880 /* [BS3CG1DST_YMM3] = */ ~0U,
881 /* [BS3CG1DST_YMM4] = */ ~0U,
882 /* [BS3CG1DST_YMM5] = */ ~0U,
883 /* [BS3CG1DST_YMM6] = */ ~0U,
884 /* [BS3CG1DST_YMM7] = */ ~0U,
885 /* [BS3CG1DST_YMM8] = */ ~0U,
886 /* [BS3CG1DST_YMM9] = */ ~0U,
887 /* [BS3CG1DST_YMM10] = */ ~0U,
888 /* [BS3CG1DST_YMM11] = */ ~0U,
889 /* [BS3CG1DST_YMM12] = */ ~0U,
890 /* [BS3CG1DST_YMM13] = */ ~0U,
891 /* [BS3CG1DST_YMM14] = */ ~0U,
892 /* [BS3CG1DST_YMM15] = */ ~0U,
893
894 /* [BS3CG1DST_VALUE_XCPT] = */ ~0U,
895};
896AssertCompile(RT_ELEMENTS(g_aoffBs3Cg1DstFields) == BS3CG1DST_END);
897
898/** Destination field names. */
899static const struct { char sz[12]; } g_aszBs3Cg1DstFields[] =
900{
901 { "INVALID" },
902 { "OP1" },
903 { "OP2" },
904 { "OP3" },
905 { "OP4" },
906 { "EFL" },
907 { "EFL_UND" },
908
909 { "AL" },
910 { "CL" },
911 { "DL" },
912 { "BL" },
913 { "AH" },
914 { "CH" },
915 { "DH" },
916 { "BH" },
917 { "SPL" },
918 { "BPL" },
919 { "SIL" },
920 { "DIL" },
921 { "R8L" },
922 { "R9L" },
923 { "R10L" },
924 { "R11L" },
925 { "R12L" },
926 { "R13L" },
927 { "R14L" },
928 { "R15L" },
929
930 { "AX" },
931 { "CX" },
932 { "DX" },
933 { "BX" },
934 { "SP" },
935 { "BP" },
936 { "SI" },
937 { "DI" },
938 { "R8W" },
939 { "R9W" },
940 { "R10W" },
941 { "R11W" },
942 { "R12W" },
943 { "R13W" },
944 { "R14W" },
945 { "R15W" },
946
947 { "EAX" },
948 { "ECX" },
949 { "EDX" },
950 { "EBX" },
951 { "ESP" },
952 { "EBP" },
953 { "ESI" },
954 { "EDI" },
955 { "R8D" },
956 { "R9D" },
957 { "R10D" },
958 { "R11D" },
959 { "R12D" },
960 { "R13D" },
961 { "R14D" },
962 { "R15D" },
963
964 { "RAX" },
965 { "RCX" },
966 { "RDX" },
967 { "RBX" },
968 { "RSP" },
969 { "RBP" },
970 { "RSI" },
971 { "RDI" },
972 { "R8" },
973 { "R9" },
974 { "R10" },
975 { "R11" },
976 { "R12" },
977 { "R13" },
978 { "R14" },
979 { "R15" },
980
981 { "OZ_RAX" },
982 { "OZ_RCX" },
983 { "OZ_RDX" },
984 { "OZ_RBX" },
985 { "OZ_RSP" },
986 { "OZ_RBP" },
987 { "OZ_RSI" },
988 { "OZ_RDI" },
989 { "OZ_R8" },
990 { "OZ_R9" },
991 { "OZ_R10" },
992 { "OZ_R11" },
993 { "OZ_R12" },
994 { "OZ_R13" },
995 { "OZ_R14" },
996 { "OZ_R15" },
997
998 { "CR0" },
999 { "CR4" },
1000 { "XCR0" },
1001
1002 { "FCW" },
1003 { "FSW" },
1004 { "FTW" },
1005 { "FOP" },
1006 { "FPUIP" },
1007 { "FPUCS" },
1008 { "FPUDP" },
1009 { "FPUDS" },
1010 { "MXCSR" },
1011 { "ST0" },
1012 { "ST1" },
1013 { "ST2" },
1014 { "ST3" },
1015 { "ST4" },
1016 { "ST5" },
1017 { "ST6" },
1018 { "ST7" },
1019 { "MM0" },
1020 { "MM1" },
1021 { "MM2" },
1022 { "MM3" },
1023 { "MM4" },
1024 { "MM5" },
1025 { "MM6" },
1026 { "MM7" },
1027 { "MM0_LO_ZX" },
1028 { "MM1_LO_ZX" },
1029 { "MM2_LO_ZX" },
1030 { "MM3_LO_ZX" },
1031 { "MM4_LO_ZX" },
1032 { "MM5_LO_ZX" },
1033 { "MM6_LO_ZX" },
1034 { "MM7_LO_ZX" },
1035 { "XMM0" },
1036 { "XMM1" },
1037 { "XMM2" },
1038 { "XMM3" },
1039 { "XMM4" },
1040 { "XMM5" },
1041 { "XMM6" },
1042 { "XMM7" },
1043 { "XMM8" },
1044 { "XMM9" },
1045 { "XMM10" },
1046 { "XMM11" },
1047 { "XMM12" },
1048 { "XMM13" },
1049 { "XMM14" },
1050 { "XMM15" },
1051 { "XMM0_LO" },
1052 { "XMM1_LO" },
1053 { "XMM2_LO" },
1054 { "XMM3_LO" },
1055 { "XMM4_LO" },
1056 { "XMM5_LO" },
1057 { "XMM6_LO" },
1058 { "XMM7_LO" },
1059 { "XMM8_LO" },
1060 { "XMM9_LO" },
1061 { "XMM10_LO" },
1062 { "XMM11_LO" },
1063 { "XMM12_LO" },
1064 { "XMM13_LO" },
1065 { "XMM14_LO" },
1066 { "XMM15_LO" },
1067 { "XMM0_HI" },
1068 { "XMM1_HI" },
1069 { "XMM2_HI" },
1070 { "XMM3_HI" },
1071 { "XMM4_HI" },
1072 { "XMM5_HI" },
1073 { "XMM6_HI" },
1074 { "XMM7_HI" },
1075 { "XMM8_HI" },
1076 { "XMM9_HI" },
1077 { "XMM10_HI" },
1078 { "XMM11_HI" },
1079 { "XMM12_HI" },
1080 { "XMM13_HI" },
1081 { "XMM14_HI" },
1082 { "XMM15_HI" },
1083 { "XMM0_LO_ZX" },
1084 { "XMM1_LO_ZX" },
1085 { "XMM2_LO_ZX" },
1086 { "XMM3_LO_ZX" },
1087 { "XMM4_LO_ZX" },
1088 { "XMM5_LO_ZX" },
1089 { "XMM6_LO_ZX" },
1090 { "XMM7_LO_ZX" },
1091 { "XMM8_LO_ZX" },
1092 { "XMM9_LO_ZX" },
1093 { "XMM10_LO_ZX" },
1094 { "XMM11_LO_ZX" },
1095 { "XMM12_LO_ZX" },
1096 { "XMM13_LO_ZX" },
1097 { "XMM14_LO_ZX" },
1098 { "XMM15_LO_ZX" },
1099 { "XMM0_DW0" },
1100 { "XMM1_DW0" },
1101 { "XMM2_DW0" },
1102 { "XMM3_DW0" },
1103 { "XMM4_DW0" },
1104 { "XMM5_DW0" },
1105 { "XMM6_DW0" },
1106 { "XMM7_DW0" },
1107 { "XMM8_DW0" },
1108 { "XMM9_DW0" },
1109 { "XMM10_DW0" },
1110 { "XMM11_DW0" },
1111 { "XMM12_DW0" },
1112 { "XMM13_DW0" },
1113 { "XMM14_DW0" },
1114 { "XMM15_DW0" },
1115 { "XMM0_DW0_ZX" },
1116 { "XMM1_DW0_ZX" },
1117 { "XMM2_DW0_ZX" },
1118 { "XMM3_DW0_ZX" },
1119 { "XMM4_DW0_ZX" },
1120 { "XMM5_DW0_ZX" },
1121 { "XMM6_DW0_ZX" },
1122 { "XMM7_DW0_ZX" },
1123 { "XMM8_DW0_ZX" },
1124 { "XMM9_DW0_ZX" },
1125 { "XMM10_DW0_ZX" },
1126 { "XMM11_DW0_ZX" },
1127 { "XMM12_DW0_ZX" },
1128 { "XMM13_DW0_ZX" },
1129 { "XMM14_DW0_ZX" },
1130 { "XMM15_DW0_ZX" },
1131 { "XMM0_HI96" },
1132 { "XMM1_HI96" },
1133 { "XMM2_HI96" },
1134 { "XMM3_HI96" },
1135 { "XMM4_HI96" },
1136 { "XMM5_HI96" },
1137 { "XMM6_HI96" },
1138 { "XMM7_HI96" },
1139 { "XMM8_HI96" },
1140 { "XMM9_HI96" },
1141 { "XMM10_HI96" },
1142 { "XMM11_HI96" },
1143 { "XMM12_HI96" },
1144 { "XMM13_HI96" },
1145 { "XMM14_HI96" },
1146 { "XMM15_HI96" },
1147 { "YMM0" },
1148 { "YMM1" },
1149 { "YMM2" },
1150 { "YMM3" },
1151 { "YMM4" },
1152 { "YMM5" },
1153 { "YMM6" },
1154 { "YMM7" },
1155 { "YMM8" },
1156 { "YMM9" },
1157 { "YMM10" },
1158 { "YMM11" },
1159 { "YMM12" },
1160 { "YMM13" },
1161 { "YMM14" },
1162 { "YMM15" },
1163
1164 { "VALXCPT" },
1165};
1166AssertCompile(RT_ELEMENTS(g_aszBs3Cg1DstFields) >= BS3CG1DST_END);
1167AssertCompile(RT_ELEMENTS(g_aszBs3Cg1DstFields) == BS3CG1DST_END);
1168
1169
1170#if 0
1171static const struct
1172{
1173 uint8_t cbPrefixes;
1174 uint8_t abPrefixes[14];
1175 uint16_t fEffective;
1176} g_aPrefixVariations[] =
1177{
1178 { 0, { 0x00 }, BS3CG1_PF_NONE },
1179
1180 { 1, { P_OZ }, BS3CG1_PF_OZ },
1181 { 1, { P_CS }, BS3CG1_PF_CS },
1182 { 1, { P_DS }, BS3CG1_PF_DS },
1183 { 1, { P_ES }, BS3CG1_PF_ES },
1184 { 1, { P_FS }, BS3CG1_PF_FS },
1185 { 1, { P_GS }, BS3CG1_PF_GS },
1186 { 1, { P_SS }, BS3CG1_PF_SS },
1187 { 1, { P_LK }, BS3CG1_PF_LK },
1188
1189 { 2, { P_CS, P_OZ, }, BS3CG1_PF_CS | BS3CFG1_PF_OZ },
1190 { 2, { P_DS, P_OZ, }, BS3CG1_PF_DS | BS3CFG1_PF_OZ },
1191 { 2, { P_ES, P_OZ, }, BS3CG1_PF_ES | BS3CFG1_PF_OZ },
1192 { 2, { P_FS, P_OZ, }, BS3CG1_PF_FS | BS3CFG1_PF_OZ },
1193 { 2, { P_GS, P_OZ, }, BS3CG1_PF_GS | BS3CFG1_PF_OZ },
1194 { 2, { P_GS, P_OZ, }, BS3CG1_PF_SS | BS3CFG1_PF_OZ },
1195 { 2, { P_SS, P_OZ, }, BS3CG1_PF_SS | BS3CFG1_PF_OZ },
1196
1197 { 2, { P_OZ, P_CS, }, BS3CG1_PF_CS | BS3CFG1_PF_OZ },
1198 { 2, { P_OZ, P_DS, }, BS3CG1_PF_DS | BS3CFG1_PF_OZ },
1199 { 2, { P_OZ, P_ES, }, BS3CG1_PF_ES | BS3CFG1_PF_OZ },
1200 { 2, { P_OZ, P_FS, }, BS3CG1_PF_FS | BS3CFG1_PF_OZ },
1201 { 2, { P_OZ, P_GS, }, BS3CG1_PF_GS | BS3CFG1_PF_OZ },
1202 { 2, { P_OZ, P_GS, }, BS3CG1_PF_SS | BS3CFG1_PF_OZ },
1203 { 2, { P_OZ, P_SS, }, BS3CG1_PF_SS | BS3CFG1_PF_OZ },
1204};
1205
1206static const uint16_t g_afPfxKindToIgnoredFlags[BS3CG1PFXKIND_END] =
1207{
1208 /* [BS3CG1PFXKIND_INVALID] = */ UINT16_MAX,
1209 /* [BS3CG1PFXKIND_MODRM] = */ 0,
1210 /* [BS3CG1PFXKIND_MODRM_NO_OP_SIZES] = */ BS3CG1_PF_OZ | BS3CG1_PF_W,
1211};
1212
1213#endif
1214
1215
1216/**
1217 * Checks if >= 16 byte SSE alignment are exempted for the exception type.
1218 *
1219 * @returns true / false.
1220 * @param enmXcptType The type to check.
1221 */
1222static bool BS3_NEAR_CODE Bs3Cg1XcptTypeIsUnaligned(BS3CG1XCPTTYPE enmXcptType)
1223{
1224 switch (enmXcptType)
1225 {
1226 case BS3CG1XCPTTYPE_1:
1227 case BS3CG1XCPTTYPE_2:
1228 case BS3CG1XCPTTYPE_4:
1229 return false;
1230 case BS3CG1XCPTTYPE_NONE:
1231 case BS3CG1XCPTTYPE_3:
1232 case BS3CG1XCPTTYPE_4UA:
1233 case BS3CG1XCPTTYPE_5:
1234 return true;
1235 default:
1236 return false;
1237 }
1238}
1239
1240
1241/**
1242 * Checks if >= 16 byte AVX alignment are exempted for the exception type.
1243 *
1244 * @returns true / false.
1245 * @param enmXcptType The type to check.
1246 */
1247static bool BS3_NEAR_CODE Bs3Cg1XcptTypeIsVexUnaligned(BS3CG1XCPTTYPE enmXcptType)
1248{
1249 switch (enmXcptType)
1250 {
1251 case BS3CG1XCPTTYPE_1:
1252 return false;
1253
1254 case BS3CG1XCPTTYPE_NONE:
1255 case BS3CG1XCPTTYPE_2:
1256 case BS3CG1XCPTTYPE_3:
1257 case BS3CG1XCPTTYPE_4:
1258 case BS3CG1XCPTTYPE_4UA:
1259 case BS3CG1XCPTTYPE_5:
1260 case BS3CG1XCPTTYPE_6:
1261 case BS3CG1XCPTTYPE_11:
1262 case BS3CG1XCPTTYPE_12:
1263 return true;
1264
1265 default:
1266 return false;
1267 }
1268}
1269
1270
1271DECLINLINE(unsigned) BS3_NEAR_CODE Bs3Cg1InsertReqPrefix(PBS3CG1STATE pThis, unsigned offDst)
1272{
1273 switch (pThis->enmPrefixKind)
1274 {
1275 case BS3CG1PFXKIND_REQ_66:
1276 pThis->abCurInstr[offDst] = 0x66;
1277 break;
1278 case BS3CG1PFXKIND_REQ_F2:
1279 pThis->abCurInstr[offDst] = 0xf2;
1280 break;
1281 case BS3CG1PFXKIND_REQ_F3:
1282 pThis->abCurInstr[offDst] = 0xf3;
1283 break;
1284 default:
1285 return offDst;
1286 }
1287 return offDst + 1;
1288}
1289
1290
1291DECLINLINE(unsigned) BS3_NEAR_CODE Bs3Cg1InsertOpcodes(PBS3CG1STATE pThis, unsigned offDst)
1292{
1293 switch (pThis->cbOpcodes)
1294 {
1295 case 4: pThis->abCurInstr[offDst + 3] = pThis->abOpcodes[3];
1296 case 3: pThis->abCurInstr[offDst + 2] = pThis->abOpcodes[2];
1297 case 2: pThis->abCurInstr[offDst + 1] = pThis->abOpcodes[1];
1298 case 1: pThis->abCurInstr[offDst] = pThis->abOpcodes[0];
1299 return offDst + pThis->cbOpcodes;
1300
1301 default:
1302 BS3_ASSERT(0);
1303 return 0;
1304 }
1305}
1306
1307
1308/**
1309 * Inserts a ModR/M byte with mod=3 and set the two idxFields members.
1310 *
1311 * @returns off + 1.
1312 * @param pThis The state.
1313 * @param off Current instruction offset.
1314 * @param uReg Register index for ModR/M.reg.
1315 * @param uRegMem Register index for ModR/M.rm.
1316 */
1317static unsigned Bs3Cg1InsertModRmWithRegFields(PBS3CG1STATE pThis, unsigned off, uint8_t uReg, uint8_t uRegMem)
1318{
1319 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, uReg & 7, uRegMem & 7);
1320 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + uReg;
1321 pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + uRegMem;
1322 return off;
1323}
1324
1325
1326
1327/**
1328 * Cleans up state and context changes made by the encoder.
1329 *
1330 * @param pThis The state.
1331 */
1332static void BS3_NEAR_CODE Bs3Cg1EncodeCleanup(PBS3CG1STATE pThis)
1333{
1334 /* Restore the DS registers in the contexts. */
1335 unsigned iRing = 4;
1336 while (iRing-- > 0)
1337 pThis->aInitialCtxs[iRing].ds = pThis->aSavedSegRegs[iRing].ds;
1338
1339 switch (pThis->enmEncoding)
1340 {
1341 /* Most encodings currently doesn't need any special cleaning up. */
1342 default:
1343 return;
1344 }
1345}
1346
1347
1348static unsigned BS3_NEAR_CODE Bs3Cfg1EncodeMemMod0Disp(PBS3CG1STATE pThis, bool fAddrOverride, unsigned off, uint8_t iReg,
1349 uint8_t cbOp, uint8_t cbMisalign, BS3CG1OPLOC enmLocation)
1350{
1351 pThis->aOperands[pThis->iRmOp].idxField = BS3CG1DST_INVALID;
1352 pThis->aOperands[pThis->iRmOp].enmLocation = enmLocation;
1353 pThis->aOperands[pThis->iRmOp].cbOp = cbOp;
1354 pThis->aOperands[pThis->iRmOp].off = cbOp + cbMisalign;
1355
1356 if ( BS3_MODE_IS_16BIT_CODE(pThis->bMode)
1357 || (fAddrOverride && BS3_MODE_IS_32BIT_CODE(pThis->bMode)) )
1358 {
1359 /*
1360 * 16-bit code doing 16-bit or 32-bit addressing,
1361 * or 32-bit code doing 16-bit addressing.
1362 */
1363 unsigned iRing = 4;
1364 if (BS3_MODE_IS_RM_OR_V86(pThis->bMode))
1365 while (iRing-- > 0)
1366 pThis->aInitialCtxs[iRing].ds = pThis->DataPgFar.sel;
1367 else
1368 while (iRing-- > 0)
1369 pThis->aInitialCtxs[iRing].ds = pThis->DataPgFar.sel | iRing;
1370 if (!fAddrOverride || BS3_MODE_IS_32BIT_CODE(pThis->bMode))
1371 {
1372 pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 6 /*disp16*/);
1373 *(uint16_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMisalign;
1374 off += 2;
1375 }
1376 else
1377 {
1378 pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 5 /*disp32*/);
1379 *(uint32_t *)&pThis->abCurInstr[off] = pThis->DataPgFar.off + X86_PAGE_SIZE - cbOp - cbMisalign;
1380 off += 4;
1381 }
1382 }
1383 else
1384 {
1385 /*
1386 * 32-bit code doing 32-bit addressing,
1387 * or 64-bit code doing either 64-bit or 32-bit addressing.
1388 */
1389 pThis->abCurInstr[off++] = X86_MODRM_MAKE(0, iReg, 5 /*disp32*/);
1390 *(uint32_t *)&pThis->abCurInstr[off] = BS3_FP_OFF(pThis->pbDataPg) + X86_PAGE_SIZE - cbOp - cbMisalign;
1391
1392#if ARCH_BITS == 64
1393 /* In 64-bit mode we always have a rip relative encoding regardless of fAddrOverride. */
1394 if (BS3CG1_IS_64BIT_TARGET(pThis))
1395 *(uint32_t *)&pThis->abCurInstr[off] -= BS3_FP_OFF(&pThis->pbCodePg[X86_PAGE_SIZE]);
1396#endif
1397 off += 4;
1398 }
1399
1400 /*
1401 * Fill the memory with 0xcc.
1402 */
1403 switch (cbOp + cbMisalign)
1404 {
1405 case 8: pThis->pbDataPg[X86_PAGE_SIZE - 8] = 0xcc; RT_FALL_THRU();
1406 case 7: pThis->pbDataPg[X86_PAGE_SIZE - 7] = 0xcc; RT_FALL_THRU();
1407 case 6: pThis->pbDataPg[X86_PAGE_SIZE - 6] = 0xcc; RT_FALL_THRU();
1408 case 5: pThis->pbDataPg[X86_PAGE_SIZE - 5] = 0xcc; RT_FALL_THRU();
1409 case 4: pThis->pbDataPg[X86_PAGE_SIZE - 4] = 0xcc; RT_FALL_THRU();
1410 case 3: pThis->pbDataPg[X86_PAGE_SIZE - 3] = 0xcc; RT_FALL_THRU();
1411 case 2: pThis->pbDataPg[X86_PAGE_SIZE - 2] = 0xcc; RT_FALL_THRU();
1412 case 1: pThis->pbDataPg[X86_PAGE_SIZE - 1] = 0xcc; RT_FALL_THRU();
1413 case 0: break;
1414 default:
1415 {
1416 BS3CG1_DPRINTF(("Bs3MemSet(%p,%#x,%#x)\n", &pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMisalign], 0xcc, cbOp - cbMisalign));
1417 Bs3MemSet(&pThis->pbDataPg[X86_PAGE_SIZE - cbOp - cbMisalign], 0xcc, cbOp - cbMisalign);
1418 break;
1419 }
1420 }
1421
1422 return off;
1423}
1424
1425
1426#if 0 /* unused */
1427/** Also encodes idxField of the register operand using idxFieldBase. */
1428static unsigned BS3_NEAR_CODE
1429Bs3Cfg1EncodeMemMod0DispWithRegField(PBS3CG1STATE pThis, bool fAddrOverride, unsigned off, uint8_t iReg,
1430 uint8_t cbOp, uint8_t cbMisalign, BS3CG1OPLOC enmLocation)
1431{
1432 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1433 return Bs3Cfg1EncodeMemMod0Disp(pThis, fAddrOverride, off, iReg & 7, cbOp, cbMisalign, enmLocation);
1434}
1435#endif
1436
1437/** Also encodes idxField of the register operand using idxFieldBase. */
1438static unsigned BS3_NEAR_CODE
1439Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(PBS3CG1STATE pThis, unsigned off, uint8_t iReg)
1440{
1441 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1442 return Bs3Cfg1EncodeMemMod0Disp(pThis, false /*fAddrOverride*/, off, iReg & 7,
1443 pThis->aOperands[pThis->iRmOp].cbOp,
1444 0 /*cbMisalign*/,
1445 pThis->aOperands[pThis->iRmOp].enmLocation);
1446}
1447
1448/** Also encodes idxField of the register operand using idxFieldBase. */
1449static unsigned BS3_NEAR_CODE
1450Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsAddrOverride(PBS3CG1STATE pThis, unsigned off, uint8_t iReg)
1451{
1452 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1453 return Bs3Cfg1EncodeMemMod0Disp(pThis, true /*fAddrOverride*/, off, iReg & 7,
1454 pThis->aOperands[pThis->iRmOp].cbOp,
1455 0 /*cbMisalign*/,
1456 pThis->aOperands[pThis->iRmOp].enmLocation);
1457}
1458
1459
1460/** Also encodes idxField of the register operand using idxFieldBase. */
1461static unsigned BS3_NEAR_CODE
1462Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(PBS3CG1STATE pThis, unsigned off, uint8_t iReg, uint8_t cbMisalign)
1463{
1464 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1465 return Bs3Cfg1EncodeMemMod0Disp(pThis, false /*fAddrOverride*/, off, iReg & 7,
1466 pThis->aOperands[pThis->iRmOp].cbOp,
1467 cbMisalign,
1468 pThis->aOperands[pThis->iRmOp].enmLocation);
1469}
1470
1471
1472/** Also encodes idxField of the register operand using idxFieldBase. */
1473static unsigned BS3_NEAR_CODE
1474Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaults(PBS3CG1STATE pThis, unsigned off, uint8_t iReg, uint8_t cbOp)
1475{
1476 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1477 return Bs3Cfg1EncodeMemMod0Disp(pThis, false /*fAddrOverride*/, off, iReg & 7, cbOp, 0 /*cbMisalign*/,
1478 pThis->aOperands[pThis->iRmOp].enmLocation);
1479}
1480
1481/** Also encodes idxField of the register operand using idxFieldBase. */
1482static unsigned BS3_NEAR_CODE
1483Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaultsAddrOverride(PBS3CG1STATE pThis, unsigned off, uint8_t iReg, uint8_t cbOp)
1484{
1485 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + iReg;
1486 return Bs3Cfg1EncodeMemMod0Disp(pThis, true /*fAddrOverride*/, off, iReg & 7, cbOp, 0 /*cbMisalign*/,
1487 pThis->aOperands[pThis->iRmOp].enmLocation);
1488}
1489
1490
1491/** The modrm.reg value is taken from the instruction byte at @a off. */
1492static unsigned BS3_NEAR_CODE
1493Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(PBS3CG1STATE pThis, unsigned off)
1494{
1495 return Bs3Cfg1EncodeMemMod0Disp(pThis, false /*fAddrOverride*/, off,
1496 (pThis->abCurInstr[off] & X86_MODRM_REG_MASK) >> X86_MODRM_REG_SHIFT,
1497 pThis->aOperands[pThis->iRmOp].cbOp,
1498 0 /*cbMisalign*/,
1499 pThis->aOperands[pThis->iRmOp].enmLocation);
1500}
1501
1502
1503
1504static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Eb_Gb_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
1505{
1506 unsigned off;
1507 switch (iEncoding)
1508 {
1509 /* Start by reg,reg encoding. */
1510 case 0:
1511 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1512 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1513 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, X86_GREG_xAX, X86_GREG_xCX);
1514 break;
1515 case 1:
1516 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1517 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1518 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5 /*CH*/);
1519 break;
1520 case 2:
1521 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) < BS3CPU_80386)
1522 return 0;
1523 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1524 pThis->abCurInstr[0] = P_OZ;
1525 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1526 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 6 /*DH*/);
1527 break;
1528 /* Tests with address overrides go last! */
1529 case 3:
1530 pThis->abCurInstr[0] = P_AZ;
1531 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
1532 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsAddrOverride(pThis, off, 7 /*BH*/);
1533 break;
1534
1535 default:
1536 return 0;
1537 }
1538 pThis->cbCurInstr = off;
1539 return iEncoding + 1;
1540}
1541
1542
1543static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Gv_Ev__OR__MODRM_Ev_Gv(PBS3CG1STATE pThis, unsigned iEncoding)
1544{
1545 unsigned off;
1546 unsigned cbOp;
1547 switch (iEncoding)
1548 {
1549 case 0:
1550 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1551 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1552 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, X86_GREG_xBX, X86_GREG_xDX);
1553 cbOp = pThis->cbOpDefault;
1554 break;
1555 case 1:
1556 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1557 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1558 cbOp = pThis->cbOpDefault;
1559 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaults(pThis, off, X86_GREG_xBP, cbOp);
1560 break;
1561 case 2:
1562 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) < BS3CPU_80386)
1563 return 0;
1564 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1565 pThis->abCurInstr[0] = P_OZ;
1566 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
1567 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, X86_GREG_xAX, X86_GREG_xCX);
1568 cbOp = pThis->cbOpOvrd66;
1569 break;
1570 case 3:
1571 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1572 pThis->abCurInstr[0] = P_OZ;
1573 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
1574 cbOp = pThis->cbOpOvrd66;
1575 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaults(pThis, off, X86_GREG_xSI, cbOp);
1576 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 2 : 0;
1577 break;
1578 case 4:
1579 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1580 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1581 pThis->abCurInstr[off++] = REX_W___;
1582 off = Bs3Cg1InsertOpcodes(pThis, off);
1583 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, X86_GREG_xBX, X86_GREG_xDX);
1584 cbOp = pThis->cbOpOvrdRexW;
1585 break;
1586 case 5:
1587 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1588 pThis->abCurInstr[off++] = REX__RB_;
1589 off = Bs3Cg1InsertOpcodes(pThis, off);
1590 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, X86_GREG_x14, X86_GREG_x12);
1591 cbOp = pThis->cbOpDefault;
1592 break;
1593 /* Tests with address overrides go last!*/
1594 case 6:
1595 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1596 pThis->abCurInstr[0] = P_AZ;
1597 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
1598 cbOp = pThis->cbOpDefault;
1599 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaultsAddrOverride(pThis, off, X86_GREG_xDI, cbOp);
1600 break;
1601 case 7:
1602 pThis->abCurInstr[0] = P_OZ;
1603 pThis->abCurInstr[1] = P_AZ;
1604 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 2));
1605 cbOp = pThis->cbOpOvrd66;
1606 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaultsAddrOverride(pThis, off, X86_GREG_xDI, cbOp);
1607 break;
1608 default:
1609 return 0;
1610 }
1611 pThis->aOperands[0].cbOp = cbOp;
1612 pThis->aOperands[1].cbOp = cbOp;
1613 pThis->cbOperand = cbOp;
1614 pThis->cbCurInstr = off;
1615 return iEncoding + 1;
1616}
1617
1618
1619static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Pq_WO_Qq(PBS3CG1STATE pThis, unsigned iEncoding)
1620{
1621 unsigned off;
1622 switch (iEncoding)
1623 {
1624 case 0:
1625 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1626 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1627 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1628 break;
1629 case 1:
1630 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1631 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1632 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 7);
1633 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1634 break;
1635#if ARCH_BITS == 64
1636 case 2:
1637 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1638 pThis->abCurInstr[off++] = REX__RBX;
1639 off = Bs3Cg1InsertOpcodes(pThis, off);
1640 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6 /*no +8*/, 2 /*no +8*/);
1641 break;
1642#endif
1643 case 3:
1644 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1645 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1646 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
1647 break;
1648 case 4:
1649 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1650 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
1651 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1652 break;
1653#if ARCH_BITS == 64
1654 case 5:
1655 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1656 pThis->abCurInstr[off++] = REX__RBX;
1657 off = Bs3Cg1InsertOpcodes(pThis, off);
1658 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 /*iReg - no +8*/);
1659 break;
1660#endif
1661
1662 default:
1663 return 0;
1664 }
1665
1666 pThis->cbCurInstr = off;
1667 return iEncoding + 1;
1668}
1669
1670
1671static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Pq_WO_Uq(PBS3CG1STATE pThis, unsigned iEncoding)
1672{
1673 unsigned off;
1674 switch (iEncoding)
1675 {
1676 case 0:
1677 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1678 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1679 break;
1680 case 1:
1681 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1682 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
1683 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1684 break;
1685 case 2:
1686 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1687 pThis->abCurInstr[off++] = REX__RBX;
1688 off = Bs3Cg1InsertOpcodes(pThis, off);
1689 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6 /*no+8*/, 2 + 8);
1690 break;
1691 default:
1692 return 0;
1693 }
1694 pThis->cbCurInstr = off;
1695 return iEncoding + 1;
1696}
1697
1698
1699static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ(PBS3CG1STATE pThis, unsigned iEncoding)
1700{
1701 unsigned off;
1702 switch (iEncoding)
1703 {
1704 case 0:
1705 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1706 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1707 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1708 break;
1709 case 1:
1710 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1711 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
1712 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1713 break;
1714#if ARCH_BITS == 64
1715 case 2:
1716 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1717 pThis->abCurInstr[off++] = REX__RBX;
1718 off = Bs3Cg1InsertOpcodes(pThis, off);
1719 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6 /*no +8*/, 2+8);
1720 break;
1721#endif
1722 case 3:
1723 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1724 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1725 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
1726 break;
1727 case 4:
1728 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1729 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
1730 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1731 break;
1732#if ARCH_BITS == 64
1733 case 5:
1734 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1735 pThis->abCurInstr[off++] = REX__RBX;
1736 off = Bs3Cg1InsertOpcodes(pThis, off);
1737 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 /*iReg*/);
1738 break;
1739#endif
1740
1741 default:
1742 return 0;
1743 }
1744 pThis->cbCurInstr = off;
1745 return iEncoding + 1;
1746}
1747
1748
1749static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ(PBS3CG1STATE pThis, unsigned iEncoding)
1750{
1751#if ARCH_BITS == 64
1752 if (BS3CG1_IS_64BIT_TARGET(pThis))
1753 {
1754 unsigned off;
1755 switch (iEncoding)
1756 {
1757 case 0:
1758 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1759 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1760 pThis->abCurInstr[off++] = REX_W___;
1761 off = Bs3Cg1InsertOpcodes(pThis, off);
1762 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1763 break;
1764 case 1:
1765 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1766 pThis->abCurInstr[off++] = REX_W___;
1767 off = Bs3Cg1InsertOpcodes(pThis, off);
1768 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
1769 break;
1770 case 2:
1771 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1772 pThis->abCurInstr[off++] = REX_WRBX;
1773 off = Bs3Cg1InsertOpcodes(pThis, off);
1774 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6 /*no +8*/, 2+8);
1775 break;
1776 case 3:
1777 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1778 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1779 pThis->abCurInstr[off++] = REX_W___;
1780 off = Bs3Cg1InsertOpcodes(pThis, off);
1781 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
1782 break;
1783 case 4:
1784 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1785 pThis->abCurInstr[off++] = REX_W___;
1786 off = Bs3Cg1InsertOpcodes(pThis, off);
1787 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
1788 break;
1789 case 5:
1790 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1791 pThis->abCurInstr[off++] = REX_WRBX;
1792 off = Bs3Cg1InsertOpcodes(pThis, off);
1793 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 /*iReg*/);
1794 break;
1795
1796 default:
1797 return 0;
1798 }
1799 pThis->cbCurInstr = off;
1800 return iEncoding + 1;
1801 }
1802#endif
1803 return 0;
1804}
1805
1806
1807/* Differs from Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ in that REX.R isn't ignored. */
1808static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vd_WO_Ed_WZ(PBS3CG1STATE pThis, unsigned iEncoding)
1809{
1810 unsigned off;
1811 switch (iEncoding)
1812 {
1813 case 0:
1814 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1815 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1816 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1817 break;
1818 case 1:
1819 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1820 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
1821 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1822 break;
1823#if ARCH_BITS == 64
1824 case 2:
1825 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1826 pThis->abCurInstr[off++] = REX__RBX;
1827 off = Bs3Cg1InsertOpcodes(pThis, off);
1828 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6+8, 2+8);
1829 break;
1830#endif
1831 case 3:
1832 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1833 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1834 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
1835 break;
1836 case 4:
1837 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1838 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
1839 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1840 break;
1841#if ARCH_BITS == 64
1842 case 5:
1843 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1844 pThis->abCurInstr[off++] = REX__RBX;
1845 off = Bs3Cg1InsertOpcodes(pThis, off);
1846 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7+8 /*iReg*/);
1847 break;
1848#endif
1849
1850 default:
1851 return 0;
1852 }
1853 pThis->cbCurInstr = off;
1854 return iEncoding + 1;
1855}
1856
1857
1858/* Differs from Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ in that REX.R isn't ignored. */
1859static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vq_WO_Eq_WNZ(PBS3CG1STATE pThis, unsigned iEncoding)
1860{
1861#if ARCH_BITS == 64
1862 if (BS3CG1_IS_64BIT_TARGET(pThis))
1863 {
1864 unsigned off;
1865 switch (iEncoding)
1866 {
1867 case 0:
1868 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1869 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1870 pThis->abCurInstr[off++] = REX_W___;
1871 off = Bs3Cg1InsertOpcodes(pThis, off);
1872 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1873 break;
1874 case 1:
1875 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1876 pThis->abCurInstr[off++] = REX_W___;
1877 off = Bs3Cg1InsertOpcodes(pThis, off);
1878 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
1879 break;
1880 case 2:
1881 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1882 pThis->abCurInstr[off++] = REX_WRBX;
1883 off = Bs3Cg1InsertOpcodes(pThis, off);
1884 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6+8, 2+8);
1885 break;
1886 case 4:
1887 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1888 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1889 pThis->abCurInstr[off++] = REX_W___;
1890 off = Bs3Cg1InsertOpcodes(pThis, off);
1891 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
1892 break;
1893 case 5:
1894 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1895 pThis->abCurInstr[off++] = REX_W___;
1896 off = Bs3Cg1InsertOpcodes(pThis, off);
1897 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
1898 break;
1899 case 6:
1900 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1901 pThis->abCurInstr[off++] = REX_WRBX;
1902 off = Bs3Cg1InsertOpcodes(pThis, off);
1903 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7+8 /*iReg*/);
1904 break;
1905
1906 default:
1907 return 0;
1908 }
1909 pThis->cbCurInstr = off;
1910 return iEncoding + 1;
1911 }
1912#endif
1913 return 0;
1914}
1915
1916
1917static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vsomething_Usomething_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
1918{
1919 unsigned off;
1920 switch (iEncoding)
1921 {
1922 case 0:
1923 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1924 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1925 break;
1926 case 1:
1927 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1928 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 2, 2);
1929 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1930 break;
1931 case 2:
1932 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1933 pThis->abCurInstr[off++] = REX__RBX;
1934 off = Bs3Cg1InsertOpcodes(pThis, off);
1935 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 3+8, 7+8);
1936 break;
1937 default:
1938 return 0;
1939 }
1940 pThis->cbCurInstr = off;
1941 return iEncoding + 1;
1942}
1943
1944
1945static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
1946{
1947 unsigned off;
1948 switch (iEncoding)
1949 {
1950 case 0:
1951 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
1952 off = Bs3Cg1InsertModRmWithRegFields(pThis, Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0)), 1, 0);
1953 break;
1954 case 1:
1955 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
1956 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1957 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2 /*iReg*/);
1958 break;
1959 case 2:
1960 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1961 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 3 /*iReg*/, 1 /*cbMisalign*/);
1962 if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
1963 pThis->bAlignmentXcpt = X86_XCPT_GP;
1964 break;
1965 default:
1966 return 0;
1967 }
1968 pThis->cbCurInstr = off;
1969 return iEncoding + 1;
1970}
1971
1972
1973static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Vsomething_Nsomething(PBS3CG1STATE pThis, unsigned iEncoding)
1974{
1975 unsigned off;
1976 switch (iEncoding)
1977 {
1978 case 0:
1979 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1980 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
1981 break;
1982 case 1:
1983 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
1984 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 7);
1985 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
1986 break;
1987 case 2:
1988 off = Bs3Cg1InsertReqPrefix(pThis, 0);
1989 pThis->abCurInstr[off++] = REX_WRBX;
1990 off = Bs3Cg1InsertOpcodes(pThis, off);
1991 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6 + 8, 7 /*no +8*/);
1992 break;
1993
1994 default:
1995 return 0;
1996 }
1997 pThis->cbCurInstr = off;
1998 return iEncoding + 1;
1999}
2000
2001
2002static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Gv_RO_Ma(PBS3CG1STATE pThis, unsigned iEncoding) /* bound instr */
2003{
2004 unsigned off;
2005 unsigned cbOp = BS3_MODE_IS_16BIT_CODE(pThis->bMode) ? 2 : 4;
2006 switch (iEncoding)
2007 {
2008 case 0:
2009 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2010 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaults(pThis, off, X86_GREG_xBP, cbOp * 2);
2011 break;
2012 case 1:
2013 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) < BS3CPU_80386)
2014 return 0;
2015 cbOp = cbOp == 2 ? 4 : 2;
2016 pThis->abCurInstr[0] = P_OZ;
2017 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
2018 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaults(pThis, off, X86_GREG_xBP, cbOp * 2);
2019 break;
2020 case 2:
2021 pThis->abCurInstr[0] = P_AZ;
2022 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
2023 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaultsAddrOverride(pThis, off, X86_GREG_xBP, cbOp * 2);
2024 break;
2025 case 3:
2026 cbOp = cbOp == 2 ? 4 : 2;
2027 pThis->abCurInstr[0] = P_AZ;
2028 pThis->abCurInstr[1] = P_OZ;
2029 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 2));
2030 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndSizeAndDefaultsAddrOverride(pThis, off, X86_GREG_xBP, cbOp * 2);
2031 break;
2032 default:
2033 return 0;
2034 }
2035 pThis->aOperands[pThis->iRegOp].cbOp = cbOp;
2036 pThis->cbOperand = cbOp;
2037 pThis->cbCurInstr = off;
2038 return iEncoding + 1;
2039}
2040
2041
2042static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Msomething(PBS3CG1STATE pThis, unsigned iEncoding)
2043{
2044 unsigned off;
2045 switch (iEncoding)
2046 {
2047 case 0:
2048 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0)) - 1;
2049 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
2050 break;
2051 default:
2052 return 0;
2053 }
2054 pThis->cbCurInstr = off;
2055 return iEncoding + 1;
2056}
2057
2058
2059static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Msomething_Psomething(PBS3CG1STATE pThis, unsigned iEncoding)
2060{
2061 unsigned off;
2062 switch (iEncoding)
2063 {
2064 case 0:
2065 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2066 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
2067 break;
2068 case 1:
2069 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2070 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 7 /*iReg*/, 1 /*cbMisalign*/);
2071 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2072 break;
2073#if ARCH_BITS == 64
2074 case 2:
2075 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2076 pThis->abCurInstr[off++] = REX__RBX;
2077 off = Bs3Cg1InsertOpcodes(pThis, off);
2078 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 /*iReg - no +8*/);
2079 break;
2080#endif
2081
2082 default:
2083 return 0;
2084 }
2085
2086 pThis->cbCurInstr = off;
2087 return iEncoding + 1;
2088}
2089
2090
2091static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2092{
2093 unsigned off;
2094 switch (iEncoding)
2095 {
2096 case 0:
2097 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2098 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2 /*iReg*/);
2099 break;
2100 case 1:
2101 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2102 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 2 /*iReg*/, 1 /*cbMisalign*/ );
2103 if (!Bs3Cg1XcptTypeIsUnaligned(pThis->enmXcptType))
2104 pThis->bAlignmentXcpt = X86_XCPT_GP;
2105 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2106 break;
2107 case 2:
2108 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2109 pThis->abCurInstr[off++] = REX__R__;
2110 off = Bs3Cg1InsertOpcodes(pThis, off);
2111 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2+8 /*iReg*/);
2112 break;
2113 default:
2114 return 0;
2115 }
2116 pThis->cbCurInstr = off;
2117 return iEncoding + 1;
2118}
2119
2120
2121static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_FIXED(PBS3CG1STATE pThis, unsigned iEncoding)
2122{
2123 unsigned off;
2124 switch (iEncoding)
2125 {
2126 case 0:
2127 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2128 pThis->cbCurInstr = off;
2129 break;
2130 default:
2131 return 0;
2132 }
2133 return iEncoding + 1;
2134}
2135
2136
2137static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_FIXED_AL_Ib(PBS3CG1STATE pThis, unsigned iEncoding)
2138{
2139 unsigned off;
2140 switch (iEncoding)
2141 {
2142 case 0:
2143 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2144 pThis->aOperands[1].off = (uint8_t)off;
2145 pThis->abCurInstr[off++] = 0xff;
2146 pThis->cbCurInstr = off;
2147 break;
2148 default:
2149 return 0;
2150 }
2151 return iEncoding + 1;
2152}
2153
2154
2155static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_FIXED_rAX_Iz(PBS3CG1STATE pThis, unsigned iEncoding)
2156{
2157 unsigned off;
2158 unsigned cbOp;
2159 switch (iEncoding)
2160 {
2161 case 0:
2162 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 0));
2163 pThis->aOperands[1].off = (uint8_t)off;
2164 cbOp = pThis->cbOpDefault;
2165 if (cbOp == 2)
2166 *(uint16_t *)&pThis->abCurInstr[off] = UINT16_MAX;
2167 else
2168 *(uint32_t *)&pThis->abCurInstr[off] = UINT32_MAX;
2169 off += cbOp;
2170 pThis->aOperands[0].cbOp = cbOp;
2171 pThis->aOperands[1].cbOp = cbOp;
2172 pThis->cbOperand = cbOp;
2173 break;
2174 case 1:
2175 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) < BS3CPU_80386)
2176 return 0;
2177 pThis->abCurInstr[0] = P_OZ;
2178 off = Bs3Cg1InsertOpcodes(pThis, Bs3Cg1InsertReqPrefix(pThis, 1));
2179 pThis->aOperands[1].off = (uint8_t)off;
2180 cbOp = pThis->cbOpOvrd66;
2181 if (cbOp == 2)
2182 *(uint16_t *)&pThis->abCurInstr[off] = UINT16_MAX;
2183 else
2184 *(uint32_t *)&pThis->abCurInstr[off] = UINT32_MAX;
2185 off += cbOp;
2186 pThis->aOperands[0].cbOp = cbOp;
2187 pThis->aOperands[1].cbOp = cbOp;
2188 pThis->cbOperand = cbOp;
2189 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2190 break;
2191 case 2:
2192 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2193 pThis->abCurInstr[off++] = REX_W___;
2194 off = Bs3Cg1InsertOpcodes(pThis, off);
2195 pThis->aOperands[1].off = (uint8_t)off;
2196 *(uint32_t *)&pThis->abCurInstr[off] = UINT32_MAX;
2197 off += 4;
2198 pThis->aOperands[0].cbOp = 8;
2199 pThis->aOperands[1].cbOp = 4;
2200 pThis->cbOperand = 8;
2201 break;
2202 default:
2203 return 0;
2204
2205 /* IMAGE PADDING - workaround for "rd err" - remove later! */
2206 case 4:
2207 ASMHalt();
2208 ASMHalt();
2209 ASMHalt();
2210 return 0;
2211
2212 }
2213 pThis->cbCurInstr = off;
2214 return iEncoding + 1;
2215}
2216
2217
2218static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_MOD_EQ_3(PBS3CG1STATE pThis, unsigned iEncoding)
2219{
2220 unsigned off;
2221 if (iEncoding < 8)
2222 {
2223 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2224 off = Bs3Cg1InsertOpcodes(pThis, off);
2225 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, iEncoding, 1);
2226 }
2227 else if (iEncoding < 16)
2228 {
2229 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2230 off = Bs3Cg1InsertOpcodes(pThis, off);
2231 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 0, iEncoding & 7);
2232 }
2233 else
2234 return 0;
2235 pThis->cbCurInstr = off;
2236
2237 return iEncoding + 1;
2238}
2239
2240
2241static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_MODRM_MOD_NE_3(PBS3CG1STATE pThis, unsigned iEncoding)
2242{
2243 unsigned off;
2244 if (iEncoding < 3)
2245 {
2246 off = Bs3Cg1InsertReqPrefix(pThis, 0);
2247 off = Bs3Cg1InsertOpcodes(pThis, off);
2248 pThis->abCurInstr[off++] = X86_MODRM_MAKE(iEncoding, 0, 1);
2249 if (iEncoding >= 1)
2250 pThis->abCurInstr[off++] = 0x7f;
2251 if (iEncoding == 2)
2252 {
2253 pThis->abCurInstr[off++] = 0x5f;
2254 if (!BS3_MODE_IS_16BIT_CODE(pThis->bMode))
2255 {
2256 pThis->abCurInstr[off++] = 0x3f;
2257 pThis->abCurInstr[off++] = 0x1f;
2258 }
2259 }
2260 }
2261 else
2262 return 0;
2263 pThis->cbCurInstr = off;
2264 return iEncoding + 1;
2265}
2266
2267
2268/*
2269 *
2270 * VEX
2271 * VEX
2272 * VEX
2273 *
2274 */
2275#ifdef BS3CG1_WITH_VEX
2276
2277/**
2278 * Inserts a 3-byte VEX prefix.
2279 *
2280 * @returns New offDst value.
2281 * @param pThis The state.
2282 * @param offDst The current instruction offset.
2283 * @param uVexL The VEX.L value.
2284 * @param uVexV The VEX.V value (caller inverted it already).
2285 * @param uVexR The VEX.R value (caller inverted it already).
2286 * @param uVexX The VEX.X value (caller inverted it already).
2287 * @param uVexB The VEX.B value (caller inverted it already).
2288 * @param uVexW The VEX.W value (straight).
2289 */
2290DECLINLINE(unsigned) BS3_NEAR_CODE Bs3Cg1InsertVex3bPrefix(PBS3CG1STATE pThis, unsigned offDst, uint8_t uVexV, uint8_t uVexL,
2291 uint8_t uVexR, uint8_t uVexX, uint8_t uVexB, uint8_t uVexW)
2292{
2293 uint8_t b1;
2294 uint8_t b2;
2295 b1 = uVexR << 7;
2296 b1 |= uVexX << 6;
2297 b1 |= uVexB << 5;
2298 b1 |= pThis->uOpcodeMap;
2299 b2 = uVexV << 3;
2300 b2 |= uVexW << 7;
2301 b2 |= uVexL << 2;
2302 switch (pThis->enmPrefixKind)
2303 {
2304 case BS3CG1PFXKIND_NO_F2_F3_66: b2 |= 0; break;
2305 case BS3CG1PFXKIND_REQ_66: b2 |= 1; break;
2306 case BS3CG1PFXKIND_REQ_F3: b2 |= 2; break;
2307 case BS3CG1PFXKIND_REQ_F2: b2 |= 3; break;
2308 default:
2309 Bs3TestFailedF("enmPrefixKind=%d not supported for VEX!\n", pThis->enmPrefixKind);
2310 break;
2311 }
2312
2313 pThis->abCurInstr[offDst] = 0xc4; /* vex3 */
2314 pThis->abCurInstr[offDst + 1] = b1;
2315 pThis->abCurInstr[offDst + 2] = b2;
2316 pThis->uVexL = uVexL;
2317 return offDst + 3;
2318}
2319
2320
2321/**
2322 * Inserts a 2-byte VEX prefix.
2323 *
2324 * @note Will switch to 3-byte VEX prefix if uOpcodeMap isn't one.
2325 *
2326 * @returns New offDst value.
2327 * @param pThis The state.
2328 * @param offDst The current instruction offset.
2329 * @param uVexL The VEX.L value.
2330 * @param uVexV The VEX.V value (caller inverted it already).
2331 * @param uVexR The VEX.R value (caller inverted it already).
2332 */
2333DECLINLINE(unsigned) BS3_NEAR_CODE Bs3Cg1InsertVex2bPrefix(PBS3CG1STATE pThis, unsigned offDst,
2334 uint8_t uVexV, uint8_t uVexL, uint8_t uVexR)
2335{
2336 if (pThis->uOpcodeMap == 1)
2337 {
2338 uint8_t b = uVexR << 7;
2339 b |= uVexV << 3;
2340 b |= uVexL << 2;
2341 switch (pThis->enmPrefixKind)
2342 {
2343 case BS3CG1PFXKIND_NO_F2_F3_66: b |= 0; break;
2344 case BS3CG1PFXKIND_REQ_66: b |= 1; break;
2345 case BS3CG1PFXKIND_REQ_F3: b |= 2; break;
2346 case BS3CG1PFXKIND_REQ_F2: b |= 3; break;
2347 default:
2348 Bs3TestFailedF("enmPrefixKind=%d not supported for VEX!\n");
2349 break;
2350 }
2351
2352 pThis->abCurInstr[offDst] = 0xc5; /* vex2 */
2353 pThis->abCurInstr[offDst + 1] = b;
2354 pThis->uVexL = uVexL;
2355 return offDst + 2;
2356 }
2357 return Bs3Cg1InsertVex3bPrefix(pThis, offDst, uVexV, uVexL, uVexR, 1 /*uVexX*/, 1 /*uVexB*/, 0/*uVexW*/);
2358}
2359
2360
2361/**
2362 * Inserts a ModR/M byte with mod=3 and set the two idxFields members.
2363 *
2364 * @returns off + 1.
2365 * @param pThis The state.
2366 * @param off Current instruction offset.
2367 * @param uReg Register index for ModR/M.reg.
2368 * @param uRegMem Register index for ModR/M.rm.
2369 * @param uVexVvvv The VEX.vvvv register.
2370 */
2371static unsigned Bs3Cg1InsertModRmWithRegFieldsAndVvvv(PBS3CG1STATE pThis, unsigned off,
2372 uint8_t uReg, uint8_t uRegMem, uint8_t uVexVvvv)
2373{
2374 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, uReg & 7, uRegMem & 7);
2375 pThis->aOperands[pThis->iRegOp].idxField = pThis->aOperands[pThis->iRegOp].idxFieldBase + uReg;
2376 pThis->aOperands[1 ].idxField = pThis->aOperands[1 ].idxFieldBase + uVexVvvv;
2377 pThis->aOperands[pThis->iRmOp ].idxField = pThis->aOperands[pThis->iRmOp ].idxFieldBase + uRegMem;
2378 return off;
2379}
2380
2381
2382static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM_Vd_WO_Ed_WZ(PBS3CG1STATE pThis, unsigned iEncoding)
2383{
2384 unsigned off;
2385 switch (iEncoding)
2386 {
2387 case 0:
2388 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
2389 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2390 off = Bs3Cg1InsertOpcodes(pThis, off);
2391 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
2392 break;
2393 case 1:
2394 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2395 off = Bs3Cg1InsertOpcodes(pThis, off);
2396 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2397 break;
2398 case 2:
2399 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L-invalid*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2400 off = Bs3Cg1InsertOpcodes(pThis, off);
2401 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2402 pThis->fInvalidEncoding = true;
2403 break;
2404 case 3:
2405 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xe /*~V-invalid*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2406 off = Bs3Cg1InsertOpcodes(pThis, off);
2407 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2408 pThis->fInvalidEncoding = true;
2409 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2410 break;
2411#if ARCH_BITS == 64
2412 case 4:
2413 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 0 /*~B*/, 0 /*W*/);
2414 off = Bs3Cg1InsertOpcodes(pThis, off);
2415 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6+8, 2+8);
2416 break;
2417#endif
2418 case 5:
2419 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
2420 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2421 off = Bs3Cg1InsertOpcodes(pThis, off);
2422 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
2423 break;
2424 case 6:
2425 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2426 off = Bs3Cg1InsertOpcodes(pThis, off);
2427 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
2428 break;
2429 case 7:
2430 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2431 off = Bs3Cg1InsertOpcodes(pThis, off);
2432 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 4 /*iReg*/, 1 /*cbMisalign*/);
2433 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 2 : 0;
2434 break;
2435#if ARCH_BITS == 64
2436 case 8:
2437 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2438 off = Bs3Cg1InsertOpcodes(pThis, off);
2439 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4+8 /*iReg*/);
2440 break;
2441 case 9:
2442 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/);
2443 off = Bs3Cg1InsertOpcodes(pThis, off);
2444 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8 /*iReg*/);
2445 iEncoding += 2;
2446 break;
2447#endif
2448 case 10: /* VEX.W is ignored in 32-bit mode. flag? */
2449 BS3_ASSERT(!BS3CG1_IS_64BIT_TARGET(pThis));
2450 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2451 off = Bs3Cg1InsertOpcodes(pThis, off);
2452 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
2453 break;
2454
2455 default:
2456 return 0;
2457 }
2458 pThis->cbCurInstr = off;
2459 return iEncoding + 1;
2460}
2461
2462
2463/* Differs from Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ in that REX.R isn't ignored. */
2464static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM_Vq_WO_Eq_WNZ(PBS3CG1STATE pThis, unsigned iEncoding)
2465{
2466#if ARCH_BITS == 64
2467 if (BS3CG1_IS_64BIT_TARGET(pThis))
2468 {
2469 unsigned off;
2470 switch (iEncoding)
2471 {
2472 case 0:
2473 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
2474 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2475 off = Bs3Cg1InsertOpcodes(pThis, off);
2476 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2477 break;
2478 case 1:
2479 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L-invalid*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2480 off = Bs3Cg1InsertOpcodes(pThis, off);
2481 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2482 pThis->fInvalidEncoding = true;
2483 break;
2484 case 2:
2485 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xe /*~V-invalid*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2486 off = Bs3Cg1InsertOpcodes(pThis, off);
2487 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6, 2);
2488 pThis->fInvalidEncoding = true;
2489 break;
2490 case 3:
2491 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 0 /*~B*/, 1 /*W*/);
2492 off = Bs3Cg1InsertOpcodes(pThis, off);
2493 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 6+8, 2+8);
2494 break;
2495 case 4:
2496 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
2497 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2498 off = Bs3Cg1InsertOpcodes(pThis, off);
2499 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4 /*iReg*/);
2500 break;
2501 case 5:
2502 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2503 off = Bs3Cg1InsertOpcodes(pThis, off);
2504 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 4 /*iReg*/, 1 /*cbMisalign*/);
2505 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 2 : 0;
2506 break;
2507 case 6:
2508 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
2509 off = Bs3Cg1InsertOpcodes(pThis, off);
2510 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 4+8 /*iReg*/);
2511 break;
2512
2513 default:
2514 return 0;
2515 }
2516 pThis->cbCurInstr = off;
2517 return iEncoding + 1;
2518 }
2519#endif
2520 return 0;
2521}
2522
2523
2524/**
2525 * Wip - VEX.W ignored.
2526 * Lig - VEX.L ignored.
2527 */
2528static unsigned BS3_NEAR_CODE
2529Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Usomething_Lip_Wip_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2530{
2531 unsigned off;
2532 switch (iEncoding)
2533 {
2534 case 0:
2535 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2536 off = Bs3Cg1InsertOpcodes(pThis, off);
2537 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2538 break;
2539 case 1:
2540 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0x8 /*~V*/, 1 /*L-ignored*/, 1 /*~R*/);
2541 off = Bs3Cg1InsertOpcodes(pThis, off);
2542 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 3, 1, 7);
2543 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2544 break;
2545 case 2:
2546#if ARCH_BITS == 64
2547 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 0 /*~R*/);
2548 off = Bs3Cg1InsertOpcodes(pThis, off);
2549 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 3+8, 2, 15);
2550 break;
2551#endif
2552 case 3:
2553 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2554 off = Bs3Cg1InsertOpcodes(pThis, off);
2555 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2556 break;
2557 case 4:
2558 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - ignored*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2559 off = Bs3Cg1InsertOpcodes(pThis, off);
2560 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2561 break;
2562 case 5:
2563 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xc /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2564 off = Bs3Cg1InsertOpcodes(pThis, off);
2565 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 3);
2566 break;
2567 case 6:
2568 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2569 off = Bs3Cg1InsertOpcodes(pThis, off);
2570 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, BS3CG1_IS_64BIT_TARGET(pThis) ? 15 : 7);
2571 break;
2572 case 7:
2573 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2574 off = Bs3Cg1InsertOpcodes(pThis, off);
2575 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, BS3CG1_IS_64BIT_TARGET(pThis) ? 15 : 7);
2576 break;
2577 default:
2578 return 0;
2579 }
2580 pThis->cbCurInstr = off;
2581 return iEncoding + 1;
2582}
2583
2584
2585/**
2586 * Wip - VEX.W ignored.
2587 */
2588static unsigned BS3_NEAR_CODE
2589Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_HdqCsomething_Usomething_Wip_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2590{
2591 unsigned off;
2592 switch (iEncoding)
2593 {
2594 case 0:
2595 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2596 off = Bs3Cg1InsertOpcodes(pThis, off);
2597 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2598 break;
2599 case 1:
2600 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0x8 /*~V*/, 1 /*L-ignored*/, 1 /*~R*/);
2601 off = Bs3Cg1InsertOpcodes(pThis, off);
2602 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 3, 1, 7);
2603 pThis->fInvalidEncoding = true;
2604 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2605 break;
2606 case 2:
2607#if ARCH_BITS == 64
2608 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 0 /*~R*/);
2609 off = Bs3Cg1InsertOpcodes(pThis, off);
2610 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 3+8, 2, 15);
2611 break;
2612#endif
2613 case 3:
2614 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2615 off = Bs3Cg1InsertOpcodes(pThis, off);
2616 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2617 break;
2618 case 4:
2619 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - ignored*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2620 off = Bs3Cg1InsertOpcodes(pThis, off);
2621 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 0);
2622 pThis->fInvalidEncoding = true;
2623 break;
2624 case 5:
2625 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xc /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2626 off = Bs3Cg1InsertOpcodes(pThis, off);
2627 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, 3);
2628 break;
2629 case 6:
2630 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2631 off = Bs3Cg1InsertOpcodes(pThis, off);
2632 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, BS3CG1_IS_64BIT_TARGET(pThis) ? 15 : 7);
2633 break;
2634 case 7:
2635 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2636 off = Bs3Cg1InsertOpcodes(pThis, off);
2637 off = Bs3Cg1InsertModRmWithRegFieldsAndVvvv(pThis, off, 2, 1, BS3CG1_IS_64BIT_TARGET(pThis) ? 15 : 7);
2638 break;
2639 default:
2640 return 0;
2641 }
2642 pThis->cbCurInstr = off;
2643 return iEncoding + 1;
2644}
2645
2646
2647/**
2648 * Wip - VEX.W ignored.
2649 */
2650static unsigned BS3_NEAR_CODE
2651Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2652{
2653 unsigned off;
2654 switch (iEncoding)
2655 {
2656 case 20: /* Switch to 256-bit operands. */
2657 pThis->aOperands[pThis->iRegOp].idxFieldBase = BS3CG1DST_YMM0;
2658 pThis->aOperands[pThis->iRegOp].cbOp = 32;
2659 pThis->aOperands[pThis->iRmOp ].cbOp = 32;
2660 RT_FALL_THRU();
2661 case 0:
2662 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/);
2663 off = Bs3Cg1InsertOpcodes(pThis, off);
2664 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2665 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2666 break;
2667#if ARCH_BITS == 64
2668 case 1:
2669 case 21:
2670 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 0 /*~R*/);
2671 off = Bs3Cg1InsertOpcodes(pThis, off);
2672 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 + 8);
2673 break;
2674#endif
2675 case 2:
2676 case 22:
2677 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/);
2678 off = Bs3Cg1InsertOpcodes(pThis, off);
2679 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2680 pThis->fInvalidEncoding = true;
2681 break;
2682 case 3:
2683 case 23:
2684 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2685 off = Bs3Cg1InsertOpcodes(pThis, off);
2686 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2687 break;
2688 case 4:
2689 case 24:
2690 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2691 off = Bs3Cg1InsertOpcodes(pThis, off);
2692 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2693 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 3 : 0;
2694 break;
2695#if ARCH_BITS == 64
2696 case 5:
2697 case 25:
2698 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2699 off = Bs3Cg1InsertOpcodes(pThis, off);
2700 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8);
2701 break;
2702 case 6:
2703 case 26:
2704 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 0 /*~B-ignored*/, 0 /*W*/);
2705 off = Bs3Cg1InsertOpcodes(pThis, off);
2706 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2707 break;
2708 case 7:
2709 case 27:
2710 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 0 /*~X-ignored*/, 1 /*~B*/, 0 /*W*/);
2711 off = Bs3Cg1InsertOpcodes(pThis, off);
2712 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2713 break;
2714#endif
2715 case 8:
2716 case 28:
2717 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2718 off = Bs3Cg1InsertOpcodes(pThis, off);
2719 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2720 pThis->fInvalidEncoding = true;
2721 break;
2722 case 9:
2723 case 29:
2724 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 7 /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2725 off = Bs3Cg1InsertOpcodes(pThis, off);
2726 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2727 pThis->fInvalidEncoding = true;
2728 iEncoding += 10;
2729 break;
2730
2731 default:
2732 return 0;
2733 }
2734 pThis->cbCurInstr = off;
2735 return iEncoding + 1;
2736}
2737
2738
2739
2740/**
2741 * Wip - VEX.W ignored.
2742 * Lig - VEX.L ignored.
2743 */
2744static unsigned BS3_NEAR_CODE
2745Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2746{
2747 unsigned off;
2748 switch (iEncoding)
2749 {
2750 case 0:
2751 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2752 off = Bs3Cg1InsertOpcodes(pThis, off);
2753 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2754 break;
2755 case 1:
2756 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - ignored*/, 1 /*~R*/);
2757 off = Bs3Cg1InsertOpcodes(pThis, off);
2758 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7);
2759 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2760 break;
2761#if ARCH_BITS == 64
2762 case 2:
2763 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - ignored*/, 0 /*~R*/);
2764 off = Bs3Cg1InsertOpcodes(pThis, off);
2765 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 + 8);
2766 break;
2767#endif
2768 case 3:
2769 iEncoding = 3;
2770 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, 0 /*L*/, 1 /*~R*/);
2771 off = Bs3Cg1InsertOpcodes(pThis, off);
2772 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2773 pThis->fInvalidEncoding = true;
2774 break;
2775 case 4:
2776 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2777 off = Bs3Cg1InsertOpcodes(pThis, off);
2778 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2779 break;
2780 case 5:
2781 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L-ignored*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2782 off = Bs3Cg1InsertOpcodes(pThis, off);
2783 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2784 break;
2785 case 6:
2786 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2787 off = Bs3Cg1InsertOpcodes(pThis, off);
2788 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2789 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 3 : 0;
2790 break;
2791#if ARCH_BITS == 64
2792 case 7:
2793 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2794 off = Bs3Cg1InsertOpcodes(pThis, off);
2795 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8);
2796 break;
2797 case 8:
2798 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 0 /*~B-ignored*/, 0 /*W*/);
2799 off = Bs3Cg1InsertOpcodes(pThis, off);
2800 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2801 break;
2802 case 9:
2803 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 0 /*~X-ignored*/, 1 /*~B*/, 0 /*W*/);
2804 off = Bs3Cg1InsertOpcodes(pThis, off);
2805 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2806 break;
2807#endif
2808 case 10:
2809 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2810 off = Bs3Cg1InsertOpcodes(pThis, off);
2811 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2812 pThis->fInvalidEncoding = true;
2813 break;
2814 case 11:
2815 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 7 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2816 off = Bs3Cg1InsertOpcodes(pThis, off);
2817 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2818 pThis->fInvalidEncoding = true;
2819 break;
2820 default:
2821 return 0;
2822 }
2823 pThis->cbCurInstr = off;
2824 return iEncoding + 1;
2825}
2826
2827
2828/**
2829 * Wip - VEX.W ignored.
2830 * L0 - VEX.L must be zero.
2831 */
2832static unsigned BS3_NEAR_CODE
2833Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lmbz_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
2834{
2835 unsigned off;
2836 switch (iEncoding)
2837 {
2838 case 0:
2839 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
2840 off = Bs3Cg1InsertOpcodes(pThis, off);
2841 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2842 break;
2843 case 1:
2844 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - invalid*/, 1 /*~R*/);
2845 off = Bs3Cg1InsertOpcodes(pThis, off);
2846 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7);
2847 pThis->fInvalidEncoding = true;
2848 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 2 : 0;
2849 break;
2850#if ARCH_BITS == 64
2851 case 2:
2852 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/);
2853 off = Bs3Cg1InsertOpcodes(pThis, off);
2854 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 + 8);
2855 break;
2856 case 3:
2857 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - invalid*/, 0 /*~R*/);
2858 off = Bs3Cg1InsertOpcodes(pThis, off);
2859 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5 + 8);
2860 pThis->fInvalidEncoding = true;
2861 break;
2862#endif
2863 case 4:
2864 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, 0 /*L*/, 1 /*~R*/);
2865 off = Bs3Cg1InsertOpcodes(pThis, off);
2866 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2867 pThis->fInvalidEncoding = true;
2868 break;
2869 case 5:
2870 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2871 off = Bs3Cg1InsertOpcodes(pThis, off);
2872 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2873 break;
2874 case 6:
2875 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L - invalid*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2876 off = Bs3Cg1InsertOpcodes(pThis, off);
2877 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2878 pThis->fInvalidEncoding = true;
2879 break;
2880 case 7:
2881 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2882 off = Bs3Cg1InsertOpcodes(pThis, off);
2883 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2884 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 3 : 0;
2885 break;
2886#if ARCH_BITS == 64
2887 case 8:
2888 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2889 off = Bs3Cg1InsertOpcodes(pThis, off);
2890 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8);
2891 break;
2892 case 9:
2893 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 0 /*~B-ignored*/, 0 /*W*/);
2894 off = Bs3Cg1InsertOpcodes(pThis, off);
2895 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2896 break;
2897 case 10:
2898 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 0 /*~X-ignored*/, 1 /*~B*/, 0 /*W*/);
2899 off = Bs3Cg1InsertOpcodes(pThis, off);
2900 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2901 break;
2902#endif
2903 case 11:
2904 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2905 off = Bs3Cg1InsertOpcodes(pThis, off);
2906 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2907 pThis->fInvalidEncoding = true;
2908 break;
2909 case 12:
2910 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 7 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2911 off = Bs3Cg1InsertOpcodes(pThis, off);
2912 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2913 pThis->fInvalidEncoding = true;
2914 break;
2915 default:
2916 return 0;
2917 }
2918 pThis->cbCurInstr = off;
2919 return iEncoding + 1;
2920}
2921
2922
2923/**
2924 * Wip - VEX.W ignored.
2925 */
2926static unsigned BS3_NEAR_CODE
2927Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lxx_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding, uint8_t uVexL)
2928{
2929 unsigned off;
2930 switch (iEncoding)
2931 {
2932 case 0:
2933 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 1 /*~R*/);
2934 off = Bs3Cg1InsertOpcodes(pThis, off);
2935 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2936 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
2937 break;
2938#if ARCH_BITS == 64
2939 case 1:
2940 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 0 /*~R*/);
2941 off = Bs3Cg1InsertOpcodes(pThis, off);
2942 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 + 8);
2943 break;
2944#endif
2945 case 2:
2946 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, uVexL, 1 /*~R*/);
2947 off = Bs3Cg1InsertOpcodes(pThis, off);
2948 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
2949 pThis->fInvalidEncoding = true;
2950 break;
2951 case 3:
2952 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2953 off = Bs3Cg1InsertOpcodes(pThis, off);
2954 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2955 break;
2956 case 4:
2957 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
2958 off = Bs3Cg1InsertOpcodes(pThis, off);
2959 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2960 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 3 : 0;
2961 break;
2962#if ARCH_BITS == 64
2963 case 5:
2964 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2965 off = Bs3Cg1InsertOpcodes(pThis, off);
2966 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8);
2967 break;
2968 case 6:
2969 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 1 /*~R*/, 1 /*~X*/, 0 /*~B-ignored*/, 0 /*W*/);
2970 off = Bs3Cg1InsertOpcodes(pThis, off);
2971 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
2972 break;
2973 case 7:
2974 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, uVexL, 1 /*~R*/, 0 /*~X-ignored*/, 1 /*~B*/, 0 /*W*/);
2975 off = Bs3Cg1InsertOpcodes(pThis, off);
2976 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2977 break;
2978#endif
2979 case 8:
2980 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, uVexL, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2981 off = Bs3Cg1InsertOpcodes(pThis, off);
2982 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
2983 pThis->fInvalidEncoding = true;
2984 break;
2985 case 9:
2986 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 7 /*~V*/, uVexL, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
2987 off = Bs3Cg1InsertOpcodes(pThis, off);
2988 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
2989 pThis->fInvalidEncoding = true;
2990 break;
2991 default:
2992 return 0;
2993 }
2994 pThis->cbCurInstr = off;
2995 return iEncoding + 1;
2996}
2997
2998
2999/**
3000 * Wip - VEX.W ignored.
3001 * L0 - VEX.L is zero (encoding may exist where it isn't).
3002 */
3003static unsigned BS3_NEAR_CODE
3004Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_L0_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
3005{
3006 return Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lxx_OR_ViceVersa(pThis, iEncoding, 0 /*uVexL*/);
3007}
3008
3009
3010/**
3011 * Wip - VEX.W ignored.
3012 * L1 - VEX.L is one (encoding may exist where it isn't).
3013 */
3014static unsigned BS3_NEAR_CODE
3015Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_L1_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
3016{
3017 return Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lxx_OR_ViceVersa(pThis, iEncoding, 1 /*uVexL*/);
3018}
3019
3020
3021
3022/**
3023 * Wip - VEX.W ignored.
3024 */
3025static unsigned BS3_NEAR_CODE
3026Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Msomething_Wip_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
3027{
3028 unsigned off;
3029 switch (iEncoding)
3030 {
3031 case 0:
3032 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xc /*~V*/, 0 /*L*/, 1 /*~R*/);
3033 off = Bs3Cg1InsertOpcodes(pThis, off);
3034 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
3035 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 3;
3036 break;
3037 case 1:
3038 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/);
3039 off = Bs3Cg1InsertOpcodes(pThis, off);
3040 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7);
3041 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3042 pThis->fInvalidEncoding = true;
3043 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
3044 break;
3045#if ARCH_BITS == 64
3046 case 2:
3047 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0x1 /*~V*/, 0 /*L*/, 0 /*~R*/);
3048 off = Bs3Cg1InsertOpcodes(pThis, off);
3049 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 7 + 8);
3050 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 14;
3051 break;
3052#endif
3053 case 3:
3054 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, 0 /*L*/, 1 /*~R*/);
3055 off = Bs3Cg1InsertOpcodes(pThis, off);
3056 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 0);
3057 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 1;
3058 break;
3059 case 4:
3060 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3061 off = Bs3Cg1InsertOpcodes(pThis, off);
3062 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
3063 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3064 break;
3065 case 5:
3066 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L-ignored*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3067 off = Bs3Cg1InsertOpcodes(pThis, off);
3068 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
3069 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3070 pThis->fInvalidEncoding = true;
3071 break;
3072 case 6:
3073 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W-ignored*/);
3074 off = Bs3Cg1InsertOpcodes(pThis, off);
3075 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
3076 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3077 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 3 : 0;
3078 break;
3079#if ARCH_BITS == 64
3080 case 7:
3081 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 0 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3082 off = Bs3Cg1InsertOpcodes(pThis, off);
3083 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5+8);
3084 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3085 break;
3086 case 8:
3087 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 0 /*~B-ignored*/, 0 /*W*/);
3088 off = Bs3Cg1InsertOpcodes(pThis, off);
3089 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 1);
3090 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3091 break;
3092 case 9:
3093 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 0 /*~X-ignored*/, 1 /*~B*/, 0 /*W*/);
3094 off = Bs3Cg1InsertOpcodes(pThis, off);
3095 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2);
3096 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + 0;
3097 break;
3098#endif
3099 case 10:
3100 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 1 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3101 off = Bs3Cg1InsertOpcodes(pThis, off);
3102 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 5);
3103 pThis->aOperands[1].idxField = pThis->aOperands[1].idxFieldBase + (BS3CG1_IS_64BIT_TARGET(pThis) ? 15 : 7);
3104 pThis->fInvalidEncoding = true;
3105 break;
3106 default:
3107 return 0;
3108 }
3109 pThis->cbCurInstr = off;
3110 return iEncoding + 1;
3111}
3112
3113
3114static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM_Md_WO(PBS3CG1STATE pThis, unsigned iEncoding)
3115{
3116 unsigned off;
3117 switch (iEncoding)
3118 {
3119 case 0:
3120 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3121 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3122 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3123 break;
3124 case 1:
3125 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3126 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3127 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3128 break;
3129 case 2:
3130 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0x7 /*~V-invalid*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3131 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3132 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3133 pThis->fInvalidEncoding = true;
3134 break;
3135 case 3:
3136 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3137 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3138 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3139 pThis->fInvalidEncoding = true;
3140 break;
3141 case 4:
3142 pThis->abCurInstr[0] = P_OZ;
3143 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3144 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3145 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3146 pThis->fInvalidEncoding = true;
3147 break;
3148 case 5:
3149 pThis->abCurInstr[0] = P_RZ;
3150 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3151 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3152 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3153 pThis->fInvalidEncoding = true;
3154 break;
3155 case 6:
3156 pThis->abCurInstr[0] = P_RN;
3157 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3158 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3159 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3160 pThis->fInvalidEncoding = true;
3161 break;
3162 case 7:
3163 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W*/);
3164 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3165 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3166 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 1 : 0;
3167 break;
3168#if ARCH_BITS == 64
3169 case 8:
3170 pThis->abCurInstr[0] = REX_____;
3171 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3172 off = Bs3Cg1InsertOpcodes(pThis, off) - 1;
3173 off = Bs3Cfg1EncodeMemMod0DispWithDefaultsAndNoReg(pThis, off);
3174 pThis->fInvalidEncoding = true;
3175 break;
3176#endif
3177 default:
3178 return 0;
3179 }
3180
3181 pThis->cbCurInstr = off;
3182 return iEncoding + 1;
3183}
3184
3185
3186/**
3187 * Wip = VEX.W ignored.
3188 * Lmbz = VEX.L must be zero.
3189 */
3190static unsigned BS3_NEAR_CODE
3191Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_Lmbz_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
3192{
3193 unsigned off;
3194 switch (iEncoding)
3195 {
3196 /* 128-bit wide stuff goes first, then we'll update the operand widths afterwards. */
3197 case 0:
3198 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
3199 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3200 off = Bs3Cg1InsertOpcodes(pThis, off);
3201 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
3202 break;
3203
3204 case 1:
3205 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3206 off = Bs3Cg1InsertOpcodes(pThis, off);
3207 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3208 break;
3209 case 2:
3210 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W - ignored*/);
3211 off = Bs3Cg1InsertOpcodes(pThis, off);
3212 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 5, 4);
3213 break;
3214 case 3:
3215 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
3216 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3217 off = Bs3Cg1InsertOpcodes(pThis, off);
3218 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2 /*iReg*/);
3219 break;
3220 case 4:
3221 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3222 off = Bs3Cg1InsertOpcodes(pThis, off);
3223 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 3 /*iReg*/);
3224 break;
3225 case 5:
3226 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W - ignored */);
3227 off = Bs3Cg1InsertOpcodes(pThis, off);
3228 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 3 /*iReg*/);
3229 break;
3230 case 6:
3231 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3232 off = Bs3Cg1InsertOpcodes(pThis, off);
3233 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 3 /*iReg*/, 1 /*cbMisalign*/);
3234 if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
3235 pThis->bAlignmentXcpt = X86_XCPT_GP;
3236 break;
3237 case 7:
3238 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3239 off = Bs3Cg1InsertOpcodes(pThis, off);
3240 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 3 /*iReg*/, 1 /*cbMisalign*/);
3241 if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
3242 pThis->bAlignmentXcpt = X86_XCPT_GP;
3243 break;
3244 /* 128-bit invalid encodings: */
3245 case 8:
3246 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
3247 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, 0 /*L*/, 1 /*~R*/); /* Bad V value */
3248 off = Bs3Cg1InsertOpcodes(pThis, off);
3249 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
3250 pThis->fInvalidEncoding = true;
3251 break;
3252 case 9:
3253 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3254 off = Bs3Cg1InsertOpcodes(pThis, off);
3255 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3256 pThis->fInvalidEncoding = true;
3257 iEncoding = 20-1;
3258 break;
3259
3260 default:
3261 return 0;
3262 }
3263
3264 pThis->cbCurInstr = off;
3265 return iEncoding + 1;
3266}
3267
3268
3269/**
3270 * Wip = VEX.W ignored.
3271 */
3272static unsigned BS3_NEAR_CODE
3273Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_OR_ViceVersa(PBS3CG1STATE pThis, unsigned iEncoding)
3274{
3275 unsigned off;
3276
3277 switch (iEncoding)
3278 {
3279 case 20: /* switch to 256-bit */
3280 pThis->aOperands[pThis->iRmOp ].cbOp = 32;
3281 pThis->aOperands[pThis->iRmOp ].idxFieldBase = BS3CG1DST_YMM0;
3282 pThis->aOperands[pThis->iRegOp].cbOp = 32;
3283 pThis->aOperands[pThis->iRegOp].idxFieldBase = BS3CG1DST_YMM0;
3284 RT_FALL_THRU();
3285 case 0:
3286 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
3287 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/);
3288 off = Bs3Cg1InsertOpcodes(pThis, off);
3289 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
3290 break;
3291
3292 case 1:
3293 case 21:
3294 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3295 off = Bs3Cg1InsertOpcodes(pThis, off);
3296 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3297 break;
3298 case 2:
3299 case 22:
3300 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W - ignored*/);
3301 off = Bs3Cg1InsertOpcodes(pThis, off);
3302 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 5, 4);
3303 break;
3304 case 3:
3305 case 23:
3306 pThis->aOperands[pThis->iRmOp].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationMem;
3307 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/);
3308 off = Bs3Cg1InsertOpcodes(pThis, off);
3309 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 2 /*iReg*/);
3310 break;
3311 case 4:
3312 case 24:
3313 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3314 off = Bs3Cg1InsertOpcodes(pThis, off);
3315 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 3 /*iReg*/);
3316 break;
3317 case 5:
3318 case 25:
3319 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 1 /*W - ignored */);
3320 off = Bs3Cg1InsertOpcodes(pThis, off);
3321 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaults(pThis, off, 3 /*iReg*/);
3322 break;
3323 case 6:
3324 case 26:
3325 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/);
3326 off = Bs3Cg1InsertOpcodes(pThis, off);
3327 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 3 /*iReg*/, 1 /*cbMisalign*/);
3328 if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
3329 pThis->bAlignmentXcpt = X86_XCPT_GP;
3330 break;
3331 case 7:
3332 case 27:
3333 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3334 off = Bs3Cg1InsertOpcodes(pThis, off);
3335 off = Bs3Cfg1EncodeMemMod0DispWithRegFieldAndDefaultsMisaligned(pThis, off, 3 /*iReg*/, 1 /*cbMisalign*/);
3336 if (!Bs3Cg1XcptTypeIsVexUnaligned(pThis->enmXcptType))
3337 pThis->bAlignmentXcpt = X86_XCPT_GP;
3338 break;
3339 /* invalid encodings: */
3340 case 8:
3341 case 28:
3342 pThis->aOperands[pThis->iRmOp ].enmLocation = pThis->aOperands[pThis->iRmOp].enmLocationReg;
3343 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xe /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/); /* Bad V value */
3344 off = Bs3Cg1InsertOpcodes(pThis, off);
3345 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1, 0);
3346 pThis->fInvalidEncoding = true;
3347 break;
3348 case 9:
3349 case 29:
3350 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0 /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3351 off = Bs3Cg1InsertOpcodes(pThis, off);
3352 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3353 pThis->fInvalidEncoding = true;
3354 break;
3355
3356 case 10:
3357 case 30:
3358 pThis->abCurInstr[0] = P_RN;
3359 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3360 off = Bs3Cg1InsertOpcodes(pThis, off);
3361 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3362 pThis->fInvalidEncoding = true;
3363 break;
3364 case 11:
3365 case 31:
3366 pThis->abCurInstr[0] = P_RZ;
3367 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3368 off = Bs3Cg1InsertOpcodes(pThis, off);
3369 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3370 pThis->fInvalidEncoding = true;
3371 break;
3372 case 12:
3373 case 32:
3374 pThis->abCurInstr[0] = P_OZ;
3375 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3376 off = Bs3Cg1InsertOpcodes(pThis, off);
3377 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3378 pThis->fInvalidEncoding = true;
3379 break;
3380 case 13:
3381 case 33:
3382 pThis->abCurInstr[0] = P_LK;
3383 off = Bs3Cg1InsertVex3bPrefix(pThis, 1 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3384 off = Bs3Cg1InsertOpcodes(pThis, off);
3385 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 4, 5);
3386 pThis->fInvalidEncoding = true;
3387 iEncoding += !BS3CG1_IS_64BIT_TARGET(pThis) ? 2 + 4 : 0;
3388 break;
3389
3390#if ARCH_BITS == 64
3391 /* 64-bit mode registers */
3392 case 14:
3393 case 34:
3394 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 0 /*~R*/);
3395 off = Bs3Cg1InsertOpcodes(pThis, off);
3396 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 3+8, 4);
3397 break;
3398 case 15:
3399 case 35:
3400 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, iEncoding >= 20 /*L*/, 0 /*~R*/, 1 /*~X*/, 0 /*~B*/, 0 /*W*/);
3401 off = Bs3Cg1InsertOpcodes(pThis, off);
3402 off = Bs3Cg1InsertModRmWithRegFields(pThis, off, 1+8, 4+8);
3403 iEncoding += 4;
3404 break;
3405#endif
3406 default:
3407 return 0;
3408 }
3409
3410 pThis->cbCurInstr = off;
3411 return iEncoding + 1;
3412}
3413
3414
3415//static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_FIXED(PBS3CG1STATE pThis, unsigned iEncoding)
3416//{
3417// unsigned off;
3418// if (iEncoding == 0)
3419// off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3420// else if (iEncoding == 0)
3421// off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3422// else
3423// return 0;
3424// pThis->cbCurInstr = off;
3425// return iEncoding + 1;
3426//}
3427
3428
3429static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM_MOD_EQ_3(PBS3CG1STATE pThis, unsigned iEncoding)
3430{
3431 unsigned off;
3432 if (iEncoding < 8)
3433 {
3434 if (iEncoding & 1)
3435 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3436 else
3437 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3438 off = Bs3Cg1InsertOpcodes(pThis, off);
3439 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, iEncoding, 1);
3440 }
3441 else if (iEncoding < 16)
3442 {
3443 if (iEncoding & 1)
3444 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/);
3445 else
3446 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 1 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3447 off = Bs3Cg1InsertOpcodes(pThis, off);
3448 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, iEncoding & 7, 1);
3449 }
3450 else if (iEncoding < 24)
3451 {
3452 if (iEncoding & 1)
3453 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/);
3454 else
3455 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, 0 /*L*/, 1 /*~R*/, 1 /*~X*/, 1 /*~B*/, 0 /*W*/);
3456 off = Bs3Cg1InsertOpcodes(pThis, off);
3457 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 0, iEncoding & 7);
3458 }
3459 else if (iEncoding < 32)
3460 {
3461 if (iEncoding & 1)
3462 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, (iEncoding & 3) != 0 /*L*/, 1 /*~R*/);
3463 else
3464 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, (iEncoding & 2) != 0 /*L*/, 1 /*~R*/, 1 /*~X*/,
3465 1 /*~B*/, (iEncoding & 4) != 0 /*W*/);
3466 off = Bs3Cg1InsertOpcodes(pThis, off);
3467 pThis->abCurInstr[off++] = X86_MODRM_MAKE(3, 0, iEncoding & 7);
3468 }
3469 else
3470 return 0;
3471 pThis->cbCurInstr = off;
3472
3473 return iEncoding + 1;
3474}
3475
3476
3477static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM_MOD_NE_3(PBS3CG1STATE pThis, unsigned iEncoding)
3478{
3479 unsigned off;
3480 if (iEncoding < 8)
3481 {
3482 unsigned iMod = iEncoding % 3;
3483 if (iEncoding & 1)
3484 off = Bs3Cg1InsertVex2bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, (iEncoding & 2) != 0 /*L*/, 1 /*~R*/);
3485 else
3486 off = Bs3Cg1InsertVex3bPrefix(pThis, 0 /*offDst*/, 0xf /*~V*/, (iEncoding & 2) != 0 /*L*/, 1 /*~R*/,
3487 1 /*~X*/, 1 /*~B*/, (iEncoding & 4) != 0 /*W*/);
3488 off = Bs3Cg1InsertOpcodes(pThis, off);
3489 pThis->abCurInstr[off++] = X86_MODRM_MAKE(iMod, 0, 1);
3490 if (iMod >= 1)
3491 pThis->abCurInstr[off++] = 0x7f;
3492 if (iMod == 2)
3493 {
3494 pThis->abCurInstr[off++] = 0x5f;
3495 if (!BS3_MODE_IS_16BIT_CODE(pThis->bMode))
3496 {
3497 pThis->abCurInstr[off++] = 0x3f;
3498 pThis->abCurInstr[off++] = 0x1f;
3499 }
3500 }
3501 }
3502 else
3503 return 0;
3504 pThis->cbCurInstr = off;
3505 return iEncoding + 1;
3506}
3507
3508
3509static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext_VEX_MODRM(PBS3CG1STATE pThis, unsigned iEncoding)
3510{
3511 const unsigned cFirstEncodings = 32;
3512 if (iEncoding < cFirstEncodings)
3513 {
3514 unsigned iRet = Bs3Cg1EncodeNext_VEX_MODRM_MOD_EQ_3(pThis, iEncoding);
3515 BS3_ASSERT(iRet > iEncoding);
3516 return iRet;
3517 }
3518 return Bs3Cg1EncodeNext_VEX_MODRM_MOD_NE_3(pThis, iEncoding - cFirstEncodings) + cFirstEncodings;
3519}
3520
3521#endif /* BS3CG1_WITH_VEX */
3522
3523
3524/**
3525 * Encodes the next instruction.
3526 *
3527 * @returns Next iEncoding value. Returns @a iEncoding unchanged to indicate
3528 * that there are no more encodings to test.
3529 * @param pThis The state.
3530 * @param iEncoding The encoding to produce. Meaning is specific to
3531 * each BS3CG1ENC_XXX value and should be considered
3532 * internal.
3533 */
3534static unsigned BS3_NEAR_CODE Bs3Cg1EncodeNext(PBS3CG1STATE pThis, unsigned iEncoding)
3535{
3536 pThis->bAlignmentXcpt = UINT8_MAX;
3537 pThis->uVexL = UINT8_MAX;
3538 if (pThis->pfnEncoder)
3539 return pThis->pfnEncoder(pThis, iEncoding);
3540
3541 Bs3TestFailedF("Internal error! BS3CG1ENC_XXX = %u not implemented", pThis->enmEncoding);
3542 return iEncoding;
3543}
3544
3545
3546/**
3547 * Prepares doing instruction encodings.
3548 *
3549 * This is in part specific to how the instruction is encoded, but generally it
3550 * sets up basic operand values that doesn't change (much) when Bs3Cg1EncodeNext
3551 * is called from within the loop.
3552 *
3553 * @returns Success indicator (true/false).
3554 * @param pThis The state.
3555 */
3556#define Bs3Cg1EncodePrep BS3_CMN_NM(Bs3Cg1EncodePrep)
3557bool BS3_NEAR_CODE Bs3Cg1EncodePrep(PBS3CG1STATE pThis)
3558{
3559 unsigned i = 4;
3560 while (i-- > 0)
3561 pThis->aSavedSegRegs[i].ds = pThis->aInitialCtxs[i].ds;
3562
3563 i = RT_ELEMENTS(pThis->aOperands);
3564 while (i-- > 0)
3565 {
3566 pThis->aOperands[i].enmLocationReg = BS3CG1OPLOC_INVALID;
3567 pThis->aOperands[i].enmLocationMem = BS3CG1OPLOC_INVALID;
3568 pThis->aOperands[i].idxFieldBase = BS3CG1DST_INVALID;
3569 }
3570
3571 pThis->iRmOp = RT_ELEMENTS(pThis->aOperands) - 1;
3572 pThis->iRegOp = RT_ELEMENTS(pThis->aOperands) - 1;
3573 pThis->fSameRingNotOkay = false;
3574 pThis->cbOperand = 0;
3575 pThis->pfnEncoder = NULL;
3576
3577 switch (pThis->enmEncoding)
3578 {
3579 case BS3CG1ENC_MODRM_Eb_Gb:
3580 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Eb_Gb_OR_ViceVersa;
3581 pThis->iRmOp = 0;
3582 pThis->iRegOp = 1;
3583 pThis->aOperands[0].cbOp = 1;
3584 pThis->aOperands[1].cbOp = 1;
3585 pThis->aOperands[0].idxFieldBase = BS3CG1DST_AL;
3586 pThis->aOperands[1].idxFieldBase = BS3CG1DST_AL;
3587 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3588 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_RW;
3589 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3590 break;
3591
3592 case BS3CG1ENC_MODRM_Ev_Gv:
3593 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Gv_Ev__OR__MODRM_Ev_Gv;
3594 pThis->iRmOp = 0;
3595 pThis->iRegOp = 1;
3596 pThis->cbOperand = 2;
3597 pThis->aOperands[0].idxFieldBase = BS3CG1DST_OZ_RAX;
3598 pThis->aOperands[1].idxFieldBase = BS3CG1DST_OZ_RAX;
3599 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3600 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_RW;
3601 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3602 break;
3603
3604 case BS3CG1ENC_MODRM_Ed_WO_Pd_WZ:
3605 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ;
3606 pThis->iRmOp = 0;
3607 pThis->iRegOp = 1;
3608 pThis->aOperands[0].cbOp = 4;
3609 pThis->aOperands[1].cbOp = 4;
3610 pThis->aOperands[0].idxFieldBase = BS3CG1DST_EAX;
3611 pThis->aOperands[1].idxFieldBase = BS3CG1DST_MM0;
3612 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3613 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3614 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3615 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3616 break;
3617
3618 case BS3CG1ENC_MODRM_Eq_WO_Pq_WNZ:
3619 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ;
3620 pThis->iRmOp = 0;
3621 pThis->iRegOp = 1;
3622 pThis->aOperands[0].cbOp = 8;
3623 pThis->aOperands[1].cbOp = 8;
3624 pThis->aOperands[0].idxFieldBase = BS3CG1DST_RAX;
3625 pThis->aOperands[1].idxFieldBase = BS3CG1DST_MM0;
3626 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3627 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3628 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3629 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3630 break;
3631
3632 case BS3CG1ENC_MODRM_Ed_WO_Vd_WZ:
3633 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vd_WO_Ed_WZ;
3634 pThis->iRmOp = 0;
3635 pThis->iRegOp = 1;
3636 pThis->aOperands[0].cbOp = 4;
3637 pThis->aOperands[1].cbOp = 4;
3638 pThis->aOperands[0].idxFieldBase = BS3CG1DST_EAX;
3639 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
3640 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3641 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3642 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3643 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3644 break;
3645
3646 case BS3CG1ENC_MODRM_Eq_WO_Vq_WNZ:
3647 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vq_WO_Eq_WNZ;
3648 pThis->iRmOp = 0;
3649 pThis->iRegOp = 1;
3650 pThis->aOperands[0].cbOp = 8;
3651 pThis->aOperands[1].cbOp = 8;
3652 pThis->aOperands[0].idxFieldBase = BS3CG1DST_RAX;
3653 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
3654 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3655 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3656 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3657 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3658 break;
3659
3660 case BS3CG1ENC_MODRM_Gb_Eb:
3661 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Eb_Gb_OR_ViceVersa;
3662 pThis->iRegOp = 0;
3663 pThis->iRmOp = 1;
3664 pThis->aOperands[0].cbOp = 1;
3665 pThis->aOperands[1].cbOp = 1;
3666 pThis->aOperands[0].idxFieldBase = BS3CG1DST_AL;
3667 pThis->aOperands[1].idxFieldBase = BS3CG1DST_AL;
3668 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3669 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3670 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3671 break;
3672
3673 case BS3CG1ENC_MODRM_Gv_Ev:
3674 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Gv_Ev__OR__MODRM_Ev_Gv;
3675 pThis->iRegOp = 0;
3676 pThis->iRmOp = 1;
3677 pThis->cbOperand = 2;
3678 pThis->aOperands[0].idxFieldBase = BS3CG1DST_OZ_RAX;
3679 pThis->aOperands[1].idxFieldBase = BS3CG1DST_OZ_RAX;
3680 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3681 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3682 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3683 break;
3684
3685 case BS3CG1ENC_MODRM_Gv_RO_Ma: /* bound instr */
3686 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Gv_RO_Ma;
3687 pThis->iRmOp = 1;
3688 pThis->iRegOp = 0;
3689 pThis->cbOperand = 2;
3690 pThis->aOperands[0].cbOp = 2;
3691 pThis->aOperands[1].cbOp = 4;
3692 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3693 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
3694 pThis->aOperands[0].idxFieldBase = BS3CG1DST_OZ_RAX;
3695 break;
3696
3697 case BS3CG1ENC_MODRM_Wss_WO_Vss:
3698 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3699 pThis->iRmOp = 0;
3700 pThis->iRegOp = 1;
3701 pThis->aOperands[0].cbOp = 4;
3702 pThis->aOperands[1].cbOp = 4;
3703 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_DW0;
3704 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_DW0;
3705 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3706 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3707 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3708 break;
3709
3710 case BS3CG1ENC_MODRM_Wsd_WO_Vsd:
3711 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3712 pThis->iRmOp = 0;
3713 pThis->iRegOp = 1;
3714 pThis->aOperands[0].cbOp = 8;
3715 pThis->aOperands[1].cbOp = 8;
3716 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
3717 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3718 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3719 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3720 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3721 break;
3722
3723 case BS3CG1ENC_MODRM_WqZxReg_WO_Vq:
3724 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3725 pThis->iRmOp = 0;
3726 pThis->iRegOp = 1;
3727 pThis->aOperands[0].cbOp = 8;
3728 pThis->aOperands[1].cbOp = 8;
3729 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
3730 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3731 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3732 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3733 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3734 break;
3735
3736 case BS3CG1ENC_MODRM_Wps_WO_Vps:
3737 case BS3CG1ENC_MODRM_Wpd_WO_Vpd:
3738 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3739 pThis->iRmOp = 0;
3740 pThis->iRegOp = 1;
3741 pThis->aOperands[0].cbOp = 16;
3742 pThis->aOperands[1].cbOp = 16;
3743 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
3744 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
3745 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
3746 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3747 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3748 break;
3749
3750 case BS3CG1ENC_MODRM_Vdq_WO_Mdq:
3751 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
3752 pThis->iRegOp = 0;
3753 pThis->iRmOp = 1;
3754 pThis->aOperands[0].cbOp = 16;
3755 pThis->aOperands[1].cbOp = 16;
3756 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3757 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
3758 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
3759 break;
3760
3761 case BS3CG1ENC_MODRM_Vdq_WO_Wdq:
3762 case BS3CG1ENC_MODRM_Vpd_WO_Wpd:
3763 case BS3CG1ENC_MODRM_Vps_WO_Wps:
3764 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3765 pThis->iRegOp = 0;
3766 pThis->iRmOp = 1;
3767 pThis->aOperands[0].cbOp = 16;
3768 pThis->aOperands[1].cbOp = 16;
3769 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
3770 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
3771 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3772 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3773 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3774 break;
3775
3776 case BS3CG1ENC_MODRM_Pq_WO_Qq:
3777 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Pq_WO_Qq;
3778 pThis->iRegOp = 0;
3779 pThis->iRmOp = 1;
3780 pThis->aOperands[0].cbOp = 8;
3781 pThis->aOperands[1].cbOp = 8;
3782 pThis->aOperands[0].idxFieldBase = BS3CG1DST_MM0;
3783 pThis->aOperands[1].idxFieldBase = BS3CG1DST_MM0;
3784 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3785 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3786 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3787 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3788 break;
3789
3790 case BS3CG1ENC_MODRM_Pq_WO_Uq:
3791 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Pq_WO_Uq;
3792 pThis->iRegOp = 0;
3793 pThis->iRmOp = 1;
3794 pThis->aOperands[0].cbOp = 8;
3795 pThis->aOperands[1].cbOp = 8;
3796 pThis->aOperands[0].idxFieldBase = BS3CG1DST_MM0;
3797 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3798 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3799 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX; /* reg only */
3800 break;
3801
3802 case BS3CG1ENC_MODRM_PdZx_WO_Ed_WZ:
3803 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_PdZx_WO_Ed_WZ;
3804 pThis->iRegOp = 0;
3805 pThis->iRmOp = 1;
3806 pThis->aOperands[0].cbOp = 4;
3807 pThis->aOperands[1].cbOp = 4;
3808 pThis->aOperands[0].idxFieldBase = BS3CG1DST_MM0_LO_ZX;
3809 pThis->aOperands[1].idxFieldBase = BS3CG1DST_EAX;
3810 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3811 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3812 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3813 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3814 break;
3815
3816 case BS3CG1ENC_MODRM_Pq_WO_Eq_WNZ:
3817 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Pq_WO_Eq_WNZ;
3818 pThis->iRegOp = 0;
3819 pThis->iRmOp = 1;
3820 pThis->aOperands[0].cbOp = 8;
3821 pThis->aOperands[1].cbOp = 8;
3822 pThis->aOperands[0].idxFieldBase = BS3CG1DST_MM0;
3823 pThis->aOperands[1].idxFieldBase = BS3CG1DST_RAX;
3824 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3825 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3826 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3827 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3828 break;
3829
3830 case BS3CG1ENC_MODRM_VdZx_WO_Ed_WZ:
3831 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vd_WO_Ed_WZ;
3832 pThis->iRegOp = 0;
3833 pThis->iRmOp = 1;
3834 pThis->aOperands[0].cbOp = 4;
3835 pThis->aOperands[1].cbOp = 4;
3836 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_DW0_ZX;
3837 pThis->aOperands[1].idxFieldBase = BS3CG1DST_EAX;
3838 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3839 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3840 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3841 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3842 break;
3843
3844 case BS3CG1ENC_MODRM_VqZx_WO_Eq_WNZ:
3845 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vq_WO_Eq_WNZ;
3846 pThis->iRegOp = 0;
3847 pThis->iRmOp = 1;
3848 pThis->aOperands[0].cbOp = 8;
3849 pThis->aOperands[1].cbOp = 8;
3850 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
3851 pThis->aOperands[1].idxFieldBase = BS3CG1DST_RAX;
3852 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3853 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3854 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3855 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3856 break;
3857
3858 case BS3CG1ENC_MODRM_Vq_WO_UqHi:
3859 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Usomething_OR_ViceVersa;
3860 pThis->iRegOp = 0;
3861 pThis->iRmOp = 1;
3862 pThis->aOperands[0].cbOp = 8;
3863 pThis->aOperands[1].cbOp = 8;
3864 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
3865 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI;
3866 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3867 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3868 break;
3869
3870 case BS3CG1ENC_MODRM_VqHi_WO_Uq:
3871 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Usomething_OR_ViceVersa;
3872 pThis->iRegOp = 0;
3873 pThis->iRmOp = 1;
3874 pThis->aOperands[0].cbOp = 8;
3875 pThis->aOperands[1].cbOp = 8;
3876 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_HI;
3877 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3878 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3879 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3880 break;
3881
3882 case BS3CG1ENC_MODRM_VqHi_WO_Mq:
3883 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
3884 pThis->iRegOp = 0;
3885 pThis->iRmOp = 1;
3886 pThis->aOperands[0].cbOp = 8;
3887 pThis->aOperands[1].cbOp = 8;
3888 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_HI;
3889 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3890 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
3891 break;
3892
3893 case BS3CG1ENC_MODRM_Vq_WO_Mq:
3894 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
3895 pThis->iRegOp = 0;
3896 pThis->iRmOp = 1;
3897 pThis->aOperands[0].cbOp = 8;
3898 pThis->aOperands[1].cbOp = 8;
3899 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
3900 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3901 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
3902 break;
3903
3904 case BS3CG1ENC_MODRM_VssZx_WO_Wss:
3905 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3906 pThis->iRegOp = 0;
3907 pThis->iRmOp = 1;
3908 pThis->aOperands[0].cbOp = 4;
3909 pThis->aOperands[1].cbOp = 4;
3910 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3911 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3912 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3913 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_DW0_ZX;
3914 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3915 break;
3916
3917 case BS3CG1ENC_MODRM_VqZx_WO_Nq:
3918 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Nsomething;
3919 pThis->iRegOp = 0;
3920 pThis->iRmOp = 1;
3921 pThis->aOperands[0].cbOp = 8;
3922 pThis->aOperands[1].cbOp = 8;
3923 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3924 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3925 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
3926 pThis->aOperands[1].idxFieldBase = BS3CG1DST_MM0;
3927 break;
3928
3929 case BS3CG1ENC_MODRM_VsdZx_WO_Wsd:
3930 case BS3CG1ENC_MODRM_VqZx_WO_Wq:
3931 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Vsomething_Wsomething_OR_ViceVersa;
3932 pThis->iRegOp = 0;
3933 pThis->iRmOp = 1;
3934 pThis->aOperands[0].cbOp = 8;
3935 pThis->aOperands[1].cbOp = 8;
3936 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
3937 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3938 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
3939 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
3940 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
3941 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
3942 break;
3943
3944 case BS3CG1ENC_MODRM_Mb_RO:
3945 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething;
3946 pThis->iRmOp = 0;
3947 pThis->aOperands[0].cbOp = 1;
3948 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM;
3949 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM;
3950 break;
3951
3952 case BS3CG1ENC_MODRM_Md_RO:
3953 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething;
3954 pThis->iRmOp = 0;
3955 pThis->aOperands[0].cbOp = 4;
3956 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM;
3957 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM;
3958 break;
3959
3960 case BS3CG1ENC_MODRM_Md_WO:
3961 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething;
3962 pThis->iRmOp = 0;
3963 pThis->aOperands[0].cbOp = 4;
3964 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
3965 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3966 break;
3967
3968 case BS3CG1ENC_MODRM_Mdq_WO_Vdq:
3969 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
3970 pThis->iRmOp = 0;
3971 pThis->iRegOp = 1;
3972 pThis->aOperands[0].cbOp = 16;
3973 pThis->aOperands[1].cbOp = 16;
3974 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
3975 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3976 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
3977 break;
3978
3979 case BS3CG1ENC_MODRM_Mq_WO_Pq:
3980 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Psomething;
3981 pThis->iRmOp = 0;
3982 pThis->iRegOp = 1;
3983 pThis->aOperands[0].cbOp = 8;
3984 pThis->aOperands[1].cbOp = 8;
3985 pThis->aOperands[1].idxFieldBase = BS3CG1DST_MM0;
3986 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
3987 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
3988 break;
3989
3990 case BS3CG1ENC_MODRM_Mq_WO_Vq:
3991 case BS3CG1ENC_MODRM_Mq_WO_VqHi:
3992 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
3993 pThis->iRmOp = 0;
3994 pThis->iRegOp = 1;
3995 pThis->aOperands[0].cbOp = 8;
3996 pThis->aOperands[1].cbOp = 8;
3997 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
3998 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
3999 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4000 pThis->aOperands[1].idxFieldBase = pThis->enmEncoding == BS3CG1ENC_MODRM_Mq_WO_Vq
4001 ? BS3CG1DST_XMM0_LO : BS3CG1DST_XMM0_HI;
4002 break;
4003
4004 case BS3CG1ENC_MODRM_Mps_WO_Vps:
4005 case BS3CG1ENC_MODRM_Mpd_WO_Vpd:
4006 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_Msomething_Vsomething_OR_ViceVersa;
4007 pThis->iRmOp = 0;
4008 pThis->iRegOp = 1;
4009 pThis->aOperands[0].cbOp = 16;
4010 pThis->aOperands[1].cbOp = 16;
4011 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4012 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4013 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4014 break;
4015
4016 case BS3CG1ENC_FIXED:
4017 pThis->pfnEncoder = Bs3Cg1EncodeNext_FIXED;
4018 break;
4019
4020 case BS3CG1ENC_FIXED_AL_Ib:
4021 pThis->pfnEncoder = Bs3Cg1EncodeNext_FIXED_AL_Ib;
4022 pThis->aOperands[0].cbOp = 1;
4023 pThis->aOperands[1].cbOp = 1;
4024 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
4025 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_IMM;
4026 pThis->aOperands[0].idxField = BS3CG1DST_AL;
4027 pThis->aOperands[1].idxField = BS3CG1DST_INVALID;
4028 break;
4029
4030 case BS3CG1ENC_FIXED_rAX_Iz:
4031 pThis->pfnEncoder = Bs3Cg1EncodeNext_FIXED_rAX_Iz;
4032 pThis->aOperands[0].cbOp = 2;
4033 pThis->aOperands[1].cbOp = 2;
4034 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
4035 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_IMM;
4036 pThis->aOperands[0].idxField = BS3CG1DST_OZ_RAX;
4037 pThis->aOperands[1].idxField = BS3CG1DST_INVALID;
4038 break;
4039
4040 /* Unused or invalid instructions mostly. */
4041 case BS3CG1ENC_MODRM_MOD_EQ_3:
4042 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_MOD_EQ_3;
4043 break;
4044 case BS3CG1ENC_MODRM_MOD_NE_3:
4045 pThis->pfnEncoder = Bs3Cg1EncodeNext_MODRM_MOD_NE_3;
4046 break;
4047
4048#ifdef BS3CG1_WITH_VEX
4049
4050 case BS3CG1ENC_VEX_MODRM_Vd_WO_Ed_WZ:
4051 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_Vd_WO_Ed_WZ;
4052 pThis->iRegOp = 0;
4053 pThis->iRmOp = 1;
4054 pThis->aOperands[0].cbOp = 4;
4055 pThis->aOperands[1].cbOp = 4;
4056 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_DW0_ZX;
4057 pThis->aOperands[1].idxFieldBase = BS3CG1DST_EAX;
4058 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4059 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4060 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
4061 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
4062 break;
4063
4064 case BS3CG1ENC_VEX_MODRM_Vq_WO_Eq_WNZ:
4065 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_Vq_WO_Eq_WNZ;
4066 pThis->iRegOp = 0;
4067 pThis->iRmOp = 1;
4068 pThis->aOperands[0].cbOp = 8;
4069 pThis->aOperands[1].cbOp = 8;
4070 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
4071 pThis->aOperands[1].idxFieldBase = BS3CG1DST_RAX;
4072 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4073 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4074 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
4075 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
4076 break;
4077
4078 case BS3CG1ENC_VEX_MODRM_Vps_WO_Wps:
4079 case BS3CG1ENC_VEX_MODRM_Vpd_WO_Wpd:
4080 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_OR_ViceVersa;
4081 pThis->iRegOp = 0;
4082 pThis->iRmOp = 1;
4083 pThis->aOperands[0].cbOp = 16;
4084 pThis->aOperands[1].cbOp = 16;
4085 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4086 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4087 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
4088 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
4089 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4090 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4091 break;
4092
4093 case BS3CG1ENC_VEX_MODRM_VssZx_WO_Md:
4094 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa;
4095 pThis->iRmOp = 1;
4096 pThis->iRegOp = 0;
4097 pThis->aOperands[0].cbOp = 4;
4098 pThis->aOperands[1].cbOp = 4;
4099 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4100 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
4101 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_DW0;
4102 pThis->aOperands[1].idxFieldBase = BS3CG1DST_INVALID;
4103 break;
4104
4105 case BS3CG1ENC_VEX_MODRM_Vss_WO_HssHi_Uss:
4106 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Usomething_Lip_Wip_OR_ViceVersa;
4107 pThis->iRegOp = 0;
4108 pThis->iRmOp = 2;
4109 pThis->aOperands[0].cbOp = 16;
4110 pThis->aOperands[1].cbOp = 12;
4111 pThis->aOperands[2].cbOp = 4;
4112 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4113 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4114 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_CTX;
4115 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4116 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI96;
4117 pThis->aOperands[2].idxFieldBase = BS3CG1DST_XMM0_DW0;
4118 break;
4119
4120 case BS3CG1ENC_VEX_MODRM_VsdZx_WO_Mq:
4121 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa;
4122 pThis->iRmOp = 1;
4123 pThis->iRegOp = 0;
4124 pThis->aOperands[0].cbOp = 8;
4125 pThis->aOperands[1].cbOp = 8;
4126 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4127 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
4128 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
4129 pThis->aOperands[1].idxFieldBase = BS3CG1DST_INVALID;
4130 break;
4131
4132 case BS3CG1ENC_VEX_MODRM_Vx_WO_Mx_L0:
4133 BS3_ASSERT(!(pThis->fFlags & BS3CG1INSTR_F_VEX_L_ZERO));
4134 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_L0_OR_ViceVersa;
4135 pThis->iRegOp = 0;
4136 pThis->iRmOp = 1;
4137 pThis->aOperands[0].cbOp = 16;
4138 pThis->aOperands[1].cbOp = 16;
4139 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4140 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
4141 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4142 break;
4143
4144 case BS3CG1ENC_VEX_MODRM_Vx_WO_Mx_L1:
4145 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_L1_OR_ViceVersa;
4146 pThis->iRegOp = 0;
4147 pThis->iRmOp = 1;
4148 pThis->aOperands[0].cbOp = 32;
4149 pThis->aOperands[1].cbOp = 32;
4150 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4151 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_MEM;
4152 pThis->aOperands[0].idxFieldBase = BS3CG1DST_YMM0;
4153 break;
4154
4155 case BS3CG1ENC_VEX_MODRM_Vsd_WO_HsdHi_Usd:
4156 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Usomething_Lip_Wip_OR_ViceVersa;
4157 pThis->iRegOp = 0;
4158 pThis->iRmOp = 2;
4159 pThis->aOperands[0].cbOp = 16;
4160 pThis->aOperands[1].cbOp = 8;
4161 pThis->aOperands[2].cbOp = 8;
4162 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4163 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4164 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_CTX;
4165 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4166 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI;
4167 pThis->aOperands[2].idxFieldBase = BS3CG1DST_XMM0_LO;
4168 break;
4169
4170 case BS3CG1ENC_VEX_MODRM_Vq_WO_HqHi_UqHi:
4171 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_HdqCsomething_Usomething_Wip_OR_ViceVersa;
4172 pThis->iRegOp = 0;
4173 pThis->iRmOp = 2;
4174 pThis->aOperands[0].cbOp = 16;
4175 pThis->aOperands[1].cbOp = 8;
4176 pThis->aOperands[2].cbOp = 8;
4177 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4178 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4179 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_CTX;
4180 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4181 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI;
4182 pThis->aOperands[2].idxFieldBase = BS3CG1DST_XMM0_HI;
4183 break;
4184
4185 case BS3CG1ENC_VEX_MODRM_Vq_WO_HqHi_Mq:
4186 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Msomething_Wip_OR_ViceVersa;
4187 pThis->iRegOp = 0;
4188 pThis->iRmOp = 2;
4189 pThis->aOperands[0].cbOp = 16;
4190 pThis->aOperands[1].cbOp = 8;
4191 pThis->aOperands[2].cbOp = 8;
4192 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4193 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4194 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_MEM;
4195 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4196 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI;
4197 pThis->aOperands[2].idxFieldBase = BS3CG1DST_INVALID;
4198 break;
4199
4200 case BS3CG1ENC_VEX_MODRM_Vq_WO_Wq:
4201 BS3_ASSERT(pThis->fFlags & BS3CG1INSTR_F_VEX_L_ZERO);
4202 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_Lmbz_OR_ViceVersa;
4203 pThis->iRegOp = 0;
4204 pThis->iRmOp = 1;
4205 pThis->aOperands[0].cbOp = 8;
4206 pThis->aOperands[1].cbOp = 8;
4207 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4208 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4209 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
4210 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
4211 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
4212 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
4213 break;
4214
4215 case BS3CG1ENC_VEX_MODRM_Vx_WO_Wx:
4216 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_OR_ViceVersa;
4217 pThis->iRegOp = 0;
4218 pThis->iRmOp = 1;
4219 pThis->aOperands[0].cbOp = 16;
4220 pThis->aOperands[1].cbOp = 16;
4221 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4222 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4223 pThis->aOperands[1].enmLocationReg = BS3CG1OPLOC_CTX;
4224 pThis->aOperands[1].enmLocationMem = BS3CG1OPLOC_MEM;
4225 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4226 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4227 break;
4228
4229 case BS3CG1ENC_VEX_MODRM_Ed_WO_Vd_WZ:
4230 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_Vd_WO_Ed_WZ;
4231 pThis->iRmOp = 0;
4232 pThis->iRegOp = 1;
4233 pThis->aOperands[0].cbOp = 4;
4234 pThis->aOperands[1].cbOp = 4;
4235 pThis->aOperands[0].idxFieldBase = BS3CG1DST_EAX;
4236 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_DW0_ZX;
4237 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
4238 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
4239 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4240 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4241 break;
4242
4243 case BS3CG1ENC_VEX_MODRM_Eq_WO_Vq_WNZ:
4244 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_Vq_WO_Eq_WNZ;
4245 pThis->iRmOp = 0;
4246 pThis->iRegOp = 1;
4247 pThis->aOperands[0].cbOp = 8;
4248 pThis->aOperands[1].cbOp = 8;
4249 pThis->aOperands[0].idxFieldBase = BS3CG1DST_RAX;
4250 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO_ZX;
4251 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX;
4252 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX;
4253 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4254 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4255 break;
4256
4257 case BS3CG1ENC_VEX_MODRM_Md_WO:
4258 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_Md_WO;
4259 pThis->iRmOp = 0;
4260 pThis->aOperands[0].cbOp = 4;
4261 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4262 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4263 break;
4264
4265 case BS3CG1ENC_VEX_MODRM_Md_WO_Vss:
4266 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa;
4267 pThis->iRmOp = 0;
4268 pThis->iRegOp = 1;
4269 pThis->aOperands[0].cbOp = 4;
4270 pThis->aOperands[1].cbOp = 4;
4271 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4272 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4273 pThis->aOperands[0].idxFieldBase = BS3CG1DST_INVALID;
4274 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_DW0;
4275 break;
4276
4277 case BS3CG1ENC_VEX_MODRM_Mq_WO_Vq:
4278 BS3_ASSERT(pThis->fFlags & (BS3CG1INSTR_F_VEX_L_ZERO | BS3CG1INSTR_F_VEX_L_IGNORED));
4279 pThis->pfnEncoder = pThis->fFlags & BS3CG1INSTR_F_VEX_L_ZERO
4280 ? Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lmbz_OR_ViceVersa
4281 : Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa;
4282 pThis->iRmOp = 0;
4283 pThis->iRegOp = 1;
4284 pThis->aOperands[0].cbOp = 8;
4285 pThis->aOperands[1].cbOp = 8;
4286 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4287 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4288 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
4289 break;
4290
4291 case BS3CG1ENC_VEX_MODRM_Mq_WO_Vsd:
4292 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_Lig_OR_ViceVersa;
4293 pThis->iRmOp = 0;
4294 pThis->iRegOp = 1;
4295 pThis->aOperands[0].cbOp = 8;
4296 pThis->aOperands[1].cbOp = 8;
4297 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4298 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4299 pThis->aOperands[0].idxFieldBase = BS3CG1DST_INVALID;
4300 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
4301 break;
4302
4303 case BS3CG1ENC_VEX_MODRM_Mps_WO_Vps:
4304 case BS3CG1ENC_VEX_MODRM_Mpd_WO_Vpd:
4305 case BS3CG1ENC_VEX_MODRM_Mx_WO_Vx:
4306 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Msomething_Wip_OR_ViceVersa;
4307 pThis->iRmOp = 0;
4308 pThis->iRegOp = 1;
4309 pThis->aOperands[0].cbOp = 16;
4310 pThis->aOperands[1].cbOp = 16;
4311 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_MEM_WO;
4312 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4313 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4314 break;
4315
4316 case BS3CG1ENC_VEX_MODRM_Uss_WO_HssHi_Vss:
4317 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Usomething_Lip_Wip_OR_ViceVersa;
4318 pThis->iRegOp = 2;
4319 pThis->iRmOp = 0;
4320 pThis->aOperands[0].cbOp = 16;
4321 pThis->aOperands[1].cbOp = 96;
4322 pThis->aOperands[2].cbOp = 4;
4323 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4324 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4325 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_CTX;
4326 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4327 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI96;
4328 pThis->aOperands[2].idxFieldBase = BS3CG1DST_XMM0_DW0;
4329 break;
4330
4331 case BS3CG1ENC_VEX_MODRM_Usd_WO_HsdHi_Vsd:
4332 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_VsomethingWO_Hsomething_Usomething_Lip_Wip_OR_ViceVersa;
4333 pThis->iRegOp = 2;
4334 pThis->iRmOp = 0;
4335 pThis->aOperands[0].cbOp = 16;
4336 pThis->aOperands[1].cbOp = 8;
4337 pThis->aOperands[2].cbOp = 8;
4338 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4339 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4340 pThis->aOperands[2].enmLocation = BS3CG1OPLOC_CTX;
4341 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4342 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_HI;
4343 pThis->aOperands[2].idxFieldBase = BS3CG1DST_XMM0_LO;
4344 break;
4345
4346 case BS3CG1ENC_VEX_MODRM_Wps_WO_Vps:
4347 case BS3CG1ENC_VEX_MODRM_Wpd_WO_Vpd:
4348 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_OR_ViceVersa;
4349 pThis->iRmOp = 0;
4350 pThis->iRegOp = 1;
4351 pThis->aOperands[0].cbOp = 16;
4352 pThis->aOperands[1].cbOp = 16;
4353 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4354 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX_ZX_VLMAX;
4355 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4356 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4357 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4358 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4359 break;
4360
4361 case BS3CG1ENC_VEX_MODRM_Wq_WO_Vq:
4362 BS3_ASSERT(pThis->fFlags & BS3CG1INSTR_F_VEX_L_ZERO);
4363 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_Lmbz_OR_ViceVersa;
4364 pThis->iRegOp = 1;
4365 pThis->iRmOp = 0;
4366 pThis->aOperands[0].cbOp = 8;
4367 pThis->aOperands[1].cbOp = 8;
4368 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4369 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX_ZX_VLMAX;
4370 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4371 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4372 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0_LO;
4373 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0_LO;
4374 break;
4375
4376 case BS3CG1ENC_VEX_MODRM_Wx_WO_Vx:
4377 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_WsomethingWO_Vsomething_Wip_OR_ViceVersa;
4378 pThis->iRmOp = 0;
4379 pThis->iRegOp = 1;
4380 pThis->aOperands[0].cbOp = 16;
4381 pThis->aOperands[1].cbOp = 16;
4382 pThis->aOperands[0].enmLocation = BS3CG1OPLOC_CTX_ZX_VLMAX;
4383 pThis->aOperands[0].enmLocationReg = BS3CG1OPLOC_CTX_ZX_VLMAX;
4384 pThis->aOperands[0].enmLocationMem = BS3CG1OPLOC_MEM_WO;
4385 pThis->aOperands[1].enmLocation = BS3CG1OPLOC_CTX;
4386 pThis->aOperands[0].idxFieldBase = BS3CG1DST_XMM0;
4387 pThis->aOperands[1].idxFieldBase = BS3CG1DST_XMM0;
4388 break;
4389
4390
4391 /* Unused or invalid instructions mostly. */
4392 //case BS3CG1ENC_VEX_FIXED:
4393 // pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_FIXED;
4394 // break;
4395 case BS3CG1ENC_VEX_MODRM_MOD_EQ_3:
4396 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_MOD_EQ_3;
4397 break;
4398 case BS3CG1ENC_VEX_MODRM_MOD_NE_3:
4399 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM_MOD_NE_3;
4400 break;
4401 case BS3CG1ENC_VEX_MODRM:
4402 pThis->pfnEncoder = Bs3Cg1EncodeNext_VEX_MODRM;
4403 break;
4404
4405#endif /* BS3CG1_WITH_VEX */
4406
4407 default:
4408 Bs3TestFailedF("Invalid/unimplemented enmEncoding for instruction #%RU32 (%.*s): %d",
4409 pThis->iInstr, pThis->cchMnemonic, pThis->pchMnemonic, pThis->enmEncoding);
4410 return false;
4411 }
4412 return true;
4413}
4414
4415
4416/**
4417 * Calculates the appropriate non-intel invalid instruction encoding.
4418 *
4419 * @returns the encoding to use instead.
4420 * @param enmEncoding The intel invalid instruction encoding.
4421 */
4422static BS3CG1ENC Bs3Cg1CalcNoneIntelInvalidEncoding(BS3CG1ENC enmEncoding)
4423{
4424 switch (enmEncoding)
4425 {
4426 case BS3CG1ENC_MODRM_Gb_Eb:
4427 case BS3CG1ENC_MODRM_Gv_RO_Ma:
4428 case BS3CG1ENC_FIXED:
4429 return BS3CG1ENC_FIXED;
4430 default:
4431 Bs3TestFailedF("Bs3Cg1CalcNoneIntelInvalidEncoding: Unsupported encoding: %d\n", enmEncoding);
4432 return BS3CG1ENC_FIXED;
4433 }
4434}
4435
4436
4437/**
4438 * Sets cbOpDefault, cbOpOvrd66 and cbOpOvrdRexW.
4439 *
4440 * @param pThis The state.
4441 * @param bMode The mode (only code part is used).
4442 */
4443static void Bs3Cg1SetOpSizes(PBS3CG1STATE pThis, uint8_t bMode)
4444{
4445 if (BS3_MODE_IS_16BIT_CODE(bMode))
4446 {
4447 pThis->cbOpDefault = 2;
4448 pThis->cbOpOvrd66 = 4;
4449 pThis->cbOpOvrdRexW = 0;
4450 }
4451 else if (BS3_MODE_IS_32BIT_CODE(bMode))
4452 {
4453 pThis->cbOpDefault = 4;
4454 pThis->cbOpOvrd66 = 2;
4455 pThis->cbOpOvrdRexW = 0;
4456 }
4457 else
4458 {
4459 pThis->cbOpDefault = 4;
4460 pThis->cbOpOvrd66 = 2;
4461 pThis->cbOpOvrdRexW = 8;
4462 }
4463}
4464
4465
4466/**
4467 * Sets up SSE and maybe AVX.
4468 *
4469 * @returns true (if successful, false if not and the SSE instructions ends up
4470 * being invalid).
4471 * @param pThis The state.
4472 */
4473static bool BS3_NEAR_CODE Bs3Cg3SetupSseAndAvx(PBS3CG1STATE pThis)
4474{
4475 if (!pThis->fWorkExtCtx)
4476 {
4477 unsigned i;
4478 uint32_t cr0 = ASMGetCR0();
4479 uint32_t cr4 = ASMGetCR4();
4480
4481 cr0 &= ~(X86_CR0_TS | X86_CR0_MP | X86_CR0_EM);
4482 cr0 |= X86_CR0_NE;
4483 ASMSetCR0(cr0);
4484 if (pThis->pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE)
4485 {
4486 cr4 |= X86_CR4_OSFXSR | X86_CR4_OSXMMEEXCPT | X86_CR4_OSXSAVE;
4487 ASMSetCR4(cr4);
4488 ASMSetXcr0(pThis->pExtCtx->fXcr0Nominal);
4489 }
4490 else
4491 {
4492 cr4 |= X86_CR4_OSFXSR | X86_CR4_OSXMMEEXCPT;
4493 ASMSetCR4(cr4);
4494 }
4495
4496 for (i = 0; i < RT_ELEMENTS(pThis->aInitialCtxs); i++)
4497 {
4498 pThis->aInitialCtxs[i].cr0.u32 = cr0;
4499 pThis->aInitialCtxs[i].cr4.u32 = cr4;
4500 }
4501 pThis->fWorkExtCtx = true;
4502 }
4503
4504 return true;
4505}
4506
4507
4508/**
4509 * Next CPU configuration to test the current instruction in.
4510 *
4511 * This is for testing FPU, SSE and AVX instructions with the various lazy state
4512 * load and enable bits in different configurations to ensure we're getting the
4513 * right response.
4514 *
4515 * This also cleans up the CPU and test driver state.
4516 *
4517 * @returns true if we're to do another round, false if we're done.
4518 * @param pThis The state.
4519 * @param iCpuSetup The current CPU setup number.
4520 * @param pfInvalidInstr Where to indicate whether the setup causes an
4521 * invalid instruction or not. This is also used as
4522 * input to avoid unnecessary CPUID work.
4523 */
4524static bool BS3_NEAR_CODE Bs3Cg1CpuSetupNext(PBS3CG1STATE pThis, unsigned iCpuSetup, bool BS3_FAR *pfInvalidInstr)
4525{
4526 if ( (pThis->fFlags & BS3CG1INSTR_F_INVALID_64BIT)
4527 && BS3CG1_IS_64BIT_TARGET(pThis))
4528 return false;
4529
4530 switch (pThis->enmCpuTest)
4531 {
4532 case BS3CG1CPU_ANY:
4533 case BS3CG1CPU_GE_80186:
4534 case BS3CG1CPU_GE_80286:
4535 case BS3CG1CPU_GE_80386:
4536 case BS3CG1CPU_GE_80486:
4537 case BS3CG1CPU_GE_Pentium:
4538 case BS3CG1CPU_CLFSH:
4539 case BS3CG1CPU_CLFLUSHOPT:
4540 return false;
4541
4542 case BS3CG1CPU_MMX:
4543 return false;
4544
4545 case BS3CG1CPU_SSE:
4546 case BS3CG1CPU_SSE2:
4547 case BS3CG1CPU_SSE3:
4548 case BS3CG1CPU_SSE4_1:
4549 case BS3CG1CPU_AVX:
4550 case BS3CG1CPU_AVX2:
4551 if (iCpuSetup > 0 || *pfInvalidInstr)
4552 {
4553 /** @todo do more configs here. */
4554 pThis->fWorkExtCtx = false;
4555 ASMSetCR0(ASMGetCR0() | X86_CR0_EM | X86_CR0_MP);
4556 ASMSetCR4(ASMGetCR4() & ~(X86_CR4_OSFXSR | X86_CR4_OSXMMEEXCPT | X86_CR4_OSXSAVE));
4557 return false;
4558 }
4559 return false;
4560
4561 default:
4562 Bs3TestFailedF("Invalid enmCpuTest value: %d", pThis->enmCpuTest);
4563 return false;
4564 }
4565}
4566
4567
4568/**
4569 * Check if the instruction is supported by the CPU, possibly making state
4570 * adjustments to enable support for it.
4571 *
4572 * @returns true if supported, false if not.
4573 * @param pThis The state.
4574 */
4575static bool BS3_NEAR_CODE Bs3Cg1CpuSetupFirst(PBS3CG1STATE pThis)
4576{
4577 uint32_t fEax;
4578 uint32_t fEbx;
4579 uint32_t fEcx;
4580 uint32_t fEdx;
4581
4582 if ( (pThis->fFlags & BS3CG1INSTR_F_INVALID_64BIT)
4583 && BS3CG1_IS_64BIT_TARGET(pThis))
4584 return false;
4585
4586 switch (pThis->enmCpuTest)
4587 {
4588 case BS3CG1CPU_ANY:
4589 return true;
4590
4591 case BS3CG1CPU_GE_80186:
4592 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80186)
4593 return true;
4594 return false;
4595
4596 case BS3CG1CPU_GE_80286:
4597 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80286)
4598 return true;
4599 return false;
4600
4601 case BS3CG1CPU_GE_80386:
4602 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386)
4603 return true;
4604 return false;
4605
4606 case BS3CG1CPU_GE_80486:
4607 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80486)
4608 return true;
4609 return false;
4610
4611 case BS3CG1CPU_GE_Pentium:
4612 if ((g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_Pentium)
4613 return true;
4614 return false;
4615
4616 case BS3CG1CPU_MMX:
4617 if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
4618 {
4619 ASMCpuIdExSlow(1, 0, 0, 0, NULL, NULL, NULL, &fEdx);
4620 if (fEdx & X86_CPUID_FEATURE_EDX_MMX)
4621 return Bs3Cg3SetupSseAndAvx(pThis); /** @todo only do FNSAVE/FXSAVE here? */
4622 }
4623 return false;
4624
4625 case BS3CG1CPU_SSE:
4626 case BS3CG1CPU_SSE2:
4627 case BS3CG1CPU_SSE3:
4628 case BS3CG1CPU_SSE4_1:
4629 case BS3CG1CPU_AVX:
4630 if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
4631 {
4632 ASMCpuIdExSlow(1, 0, 0, 0, NULL, NULL, &fEcx, &fEdx);
4633 switch (pThis->enmCpuTest)
4634 {
4635 case BS3CG1CPU_SSE:
4636 if (fEdx & X86_CPUID_FEATURE_EDX_SSE)
4637 return Bs3Cg3SetupSseAndAvx(pThis);
4638 return false;
4639 case BS3CG1CPU_SSE2:
4640 if (fEdx & X86_CPUID_FEATURE_EDX_SSE2)
4641 return Bs3Cg3SetupSseAndAvx(pThis);
4642 return false;
4643 case BS3CG1CPU_SSE3:
4644 if (fEcx & X86_CPUID_FEATURE_ECX_SSE3)
4645 return Bs3Cg3SetupSseAndAvx(pThis);
4646 return false;
4647 case BS3CG1CPU_SSE4_1:
4648 if (fEcx & X86_CPUID_FEATURE_ECX_SSE4_1)
4649 return Bs3Cg3SetupSseAndAvx(pThis);
4650 return false;
4651 case BS3CG1CPU_AVX:
4652 if (fEcx & X86_CPUID_FEATURE_ECX_AVX)
4653 return Bs3Cg3SetupSseAndAvx(pThis) && !BS3_MODE_IS_RM_OR_V86(pThis->bMode);
4654 return false;
4655 default: BS3_ASSERT(0); /* impossible */
4656 }
4657 }
4658 return false;
4659
4660 case BS3CG1CPU_AVX2:
4661 if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
4662 {
4663 ASMCpuIdExSlow(7, 0, 0/*leaf*/, 0, &fEax, &fEbx, &fEcx, &fEdx);
4664 switch (pThis->enmCpuTest)
4665 {
4666 case BS3CG1CPU_AVX2:
4667 if (fEbx & X86_CPUID_STEXT_FEATURE_EBX_AVX2)
4668 return Bs3Cg3SetupSseAndAvx(pThis) && !BS3_MODE_IS_RM_OR_V86(pThis->bMode);
4669 return false;
4670 default: BS3_ASSERT(0); return false; /* impossible */
4671 }
4672 }
4673 return false;
4674
4675 case BS3CG1CPU_CLFSH:
4676 if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
4677 {
4678 ASMCpuIdExSlow(1, 0, 0, 0, NULL, NULL, NULL, &fEdx);
4679 if (fEdx & X86_CPUID_FEATURE_EDX_CLFSH)
4680 return true;
4681 }
4682 return false;
4683
4684 case BS3CG1CPU_CLFLUSHOPT:
4685 if (g_uBs3CpuDetected & BS3CPU_F_CPUID)
4686 {
4687 ASMCpuIdExSlow(7, 0, 0/*leaf*/, 0, NULL, &fEbx, NULL, NULL);
4688 if (fEbx & X86_CPUID_STEXT_FEATURE_EBX_CLFLUSHOPT)
4689 return true;
4690 }
4691 return false;
4692
4693 default:
4694 Bs3TestFailedF("Invalid enmCpuTest value: %d", pThis->enmCpuTest);
4695 return false;
4696 }
4697}
4698
4699
4700
4701/**
4702 * Checks the preconditions for a test.
4703 *
4704 * @returns true if the test be executed, false if not.
4705 * @param pThis The state.
4706 * @param pHdr The test header.
4707 */
4708static bool BS3_NEAR_CODE Bs3Cg1RunSelector(PBS3CG1STATE pThis, PCBS3CG1TESTHDR pHdr)
4709{
4710
4711 uint8_t const BS3_FAR *pbCode = (uint8_t const BS3_FAR *)(pHdr + 1);
4712 unsigned cbLeft = pHdr->cbSelector;
4713 while (cbLeft-- > 0)
4714 {
4715 switch (*pbCode++)
4716 {
4717#define CASE_PRED(a_Pred, a_Expr) \
4718 case ((a_Pred) << BS3CG1SEL_OP_KIND_MASK) | BS3CG1SEL_OP_IS_TRUE: \
4719 if (!(a_Expr)) return false; \
4720 break; \
4721 case ((a_Pred) << BS3CG1SEL_OP_KIND_MASK) | BS3CG1SEL_OP_IS_FALSE: \
4722 if (a_Expr) return false; \
4723 break
4724 CASE_PRED(BS3CG1PRED_SIZE_O16, pThis->cbOperand == 2);
4725 CASE_PRED(BS3CG1PRED_SIZE_O32, pThis->cbOperand == 4);
4726 CASE_PRED(BS3CG1PRED_SIZE_O64, pThis->cbOperand == 8);
4727 CASE_PRED(BS3CG1PRED_VEXL_0, pThis->uVexL == 0);
4728 CASE_PRED(BS3CG1PRED_VEXL_1, pThis->uVexL == 1);
4729 CASE_PRED(BS3CG1PRED_RING_0, pThis->uCpl == 0);
4730 CASE_PRED(BS3CG1PRED_RING_1, pThis->uCpl == 1);
4731 CASE_PRED(BS3CG1PRED_RING_2, pThis->uCpl == 2);
4732 CASE_PRED(BS3CG1PRED_RING_3, pThis->uCpl == 3);
4733 CASE_PRED(BS3CG1PRED_RING_0_THRU_2, pThis->uCpl <= 2);
4734 CASE_PRED(BS3CG1PRED_RING_1_THRU_3, pThis->uCpl >= 1);
4735 CASE_PRED(BS3CG1PRED_CODE_64BIT, BS3CG1_IS_64BIT_TARGET(pThis));
4736 CASE_PRED(BS3CG1PRED_CODE_32BIT, BS3_MODE_IS_32BIT_CODE(pThis->bMode));
4737 CASE_PRED(BS3CG1PRED_CODE_16BIT, BS3_MODE_IS_16BIT_CODE(pThis->bMode));
4738 CASE_PRED(BS3CG1PRED_MODE_REAL, BS3_MODE_IS_RM_SYS(pThis->bMode));
4739 CASE_PRED(BS3CG1PRED_MODE_PROT, BS3_MODE_IS_PM_SYS(pThis->bMode));
4740 CASE_PRED(BS3CG1PRED_MODE_LONG, BS3_MODE_IS_64BIT_SYS(pThis->bMode));
4741 CASE_PRED(BS3CG1PRED_MODE_SMM, false);
4742 CASE_PRED(BS3CG1PRED_MODE_VMX, false);
4743 CASE_PRED(BS3CG1PRED_MODE_SVM, false);
4744 CASE_PRED(BS3CG1PRED_PAGING_ON, BS3_MODE_IS_PAGED(pThis->bMode));
4745 CASE_PRED(BS3CG1PRED_PAGING_OFF, !BS3_MODE_IS_PAGED(pThis->bMode));
4746 CASE_PRED(BS3CG1PRED_VENDOR_AMD, pThis->bCpuVendor == BS3CPUVENDOR_AMD);
4747 CASE_PRED(BS3CG1PRED_VENDOR_INTEL, pThis->bCpuVendor == BS3CPUVENDOR_INTEL);
4748 CASE_PRED(BS3CG1PRED_VENDOR_VIA, pThis->bCpuVendor == BS3CPUVENDOR_VIA);
4749 CASE_PRED(BS3CG1PRED_VENDOR_SHANGHAI, pThis->bCpuVendor == BS3CPUVENDOR_SHANGHAI);
4750 CASE_PRED(BS3CG1PRED_VENDOR_HYGON, pThis->bCpuVendor == BS3CPUVENDOR_HYGON);
4751
4752#undef CASE_PRED
4753 default:
4754 return Bs3TestFailedF("Invalid selector opcode %#x!", pbCode[-1]);
4755 }
4756 }
4757
4758 return true;
4759}
4760
4761
4762#ifdef BS3CG1_DEBUG_CTX_MOD
4763/**
4764 * Translates the operator into a string.
4765 *
4766 * @returns Read-only string pointer.
4767 * @param bOpcode The context modifier program opcode.
4768 */
4769static const char BS3_FAR * BS3_NEAR_CODE Bs3Cg1CtxOpToString(uint8_t bOpcode)
4770{
4771 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
4772 {
4773 case BS3CG1_CTXOP_ASSIGN: return "=";
4774 case BS3CG1_CTXOP_OR: return "|=";
4775 case BS3CG1_CTXOP_AND: return "&=";
4776 case BS3CG1_CTXOP_AND_INV: return "&~=";
4777 default: return "?WTF?";
4778 }
4779}
4780#endif
4781
4782
4783/**
4784 * Runs a context modifier program.
4785 *
4786 * @returns Success indicator (true/false).
4787 * @param pThis The state.
4788 * @param pCtx The context.
4789 * @param pHdr The program header.
4790 * @param off The program offset relative to the end of the header.
4791 * @param cb The program size.
4792 * @param pEflCtx The context to take undefined EFLAGS from. (This is NULL
4793 * if we're processing a input context modifier program.)
4794 * @param pbInstr Points to the first instruction byte. For storing
4795 * immediate operands during input context modification.
4796 * NULL for output contexts.
4797 */
4798static bool BS3_NEAR_CODE Bs3Cg1RunContextModifier(PBS3CG1STATE pThis, PBS3REGCTX pCtx, PCBS3CG1TESTHDR pHdr,
4799 unsigned off, unsigned cb,
4800 PCBS3REGCTX pEflCtx, uint8_t BS3_FAR *pbInstr)
4801{
4802 uint8_t const BS3_FAR *pbCode = (uint8_t const BS3_FAR *)(pHdr + 1) + off;
4803 int cbLeft = cb;
4804 while (cbLeft-- > 0)
4805 {
4806 /*
4807 * Decode the instruction.
4808 */
4809 uint8_t const bOpcode = *pbCode++;
4810 unsigned cbValue;
4811 unsigned cbDst;
4812 BS3CG1DST idxField;
4813 BS3PTRUNION PtrField;
4814 uint8_t BS3_FAR *pbMemCopy = NULL;
4815 bool fZxVlMax;
4816
4817 /* Expand the destiation field (can be escaped). Set fZxVlMax. */
4818 switch (bOpcode & BS3CG1_CTXOP_DST_MASK)
4819 {
4820 case BS3CG1_CTXOP_OP1:
4821 idxField = pThis->aOperands[0].idxField;
4822 if (idxField == BS3CG1DST_INVALID)
4823 idxField = BS3CG1DST_OP1;
4824 fZxVlMax = pEflCtx != NULL && pThis->aOperands[0].enmLocation == BS3CG1OPLOC_CTX_ZX_VLMAX;
4825 break;
4826
4827 case BS3CG1_CTXOP_OP2:
4828 idxField = pThis->aOperands[1].idxField;
4829 if (idxField == BS3CG1DST_INVALID)
4830 idxField = BS3CG1DST_OP2;
4831 fZxVlMax = pEflCtx != NULL && pThis->aOperands[1].enmLocation == BS3CG1OPLOC_CTX_ZX_VLMAX;
4832 break;
4833
4834 case BS3CG1_CTXOP_EFL:
4835 idxField = BS3CG1DST_EFL;
4836 fZxVlMax = false;
4837 break;
4838
4839 case BS3CG1_CTXOP_DST_ESC:
4840 if (cbLeft-- > 0)
4841 {
4842 idxField = (BS3CG1DST)*pbCode++;
4843 if (idxField <= BS3CG1DST_OP4)
4844 {
4845 if (idxField > BS3CG1DST_INVALID)
4846 {
4847 unsigned idxOp = idxField - BS3CG1DST_OP1;
4848 uint8_t idxField2 = pThis->aOperands[idxOp].idxField;
4849 if (idxField2 != BS3CG1DST_INVALID)
4850 idxField = idxField2;
4851 fZxVlMax = pEflCtx != NULL && pThis->aOperands[idxOp].enmLocation == BS3CG1OPLOC_CTX_ZX_VLMAX;
4852 break;
4853 }
4854 }
4855 else if (idxField < BS3CG1DST_END)
4856 {
4857 fZxVlMax = false;
4858 break;
4859 }
4860 return Bs3TestFailedF("Malformed context instruction: idxField=%d", idxField);
4861 }
4862 RT_FALL_THRU();
4863 default:
4864 return Bs3TestFailed("Malformed context instruction: Destination");
4865 }
4866
4867 /* Expand value size (can be escaped). */
4868 switch (bOpcode & BS3CG1_CTXOP_SIZE_MASK)
4869 {
4870 case BS3CG1_CTXOP_1_BYTE: cbValue = 1; break;
4871 case BS3CG1_CTXOP_2_BYTES: cbValue = 2; break;
4872 case BS3CG1_CTXOP_4_BYTES: cbValue = 4; break;
4873 case BS3CG1_CTXOP_8_BYTES: cbValue = 8; break;
4874 case BS3CG1_CTXOP_16_BYTES: cbValue = 16; break;
4875 case BS3CG1_CTXOP_32_BYTES: cbValue = 32; break;
4876 case BS3CG1_CTXOP_12_BYTES: cbValue = 12; break;
4877 case BS3CG1_CTXOP_SIZE_ESC:
4878 if (cbLeft-- > 0)
4879 {
4880 cbValue = *pbCode++;
4881 if (cbValue)
4882 break;
4883 }
4884 RT_FALL_THRU();
4885 default:
4886 return Bs3TestFailed("Malformed context instruction: size");
4887 }
4888
4889 /* Make sure there is enough instruction bytes for the value. */
4890 if (cbValue <= cbLeft)
4891 { /* likely */ }
4892 else
4893 return Bs3TestFailedF("Malformed context instruction: %u bytes value, %u bytes left", cbValue, cbLeft);
4894
4895 /*
4896 * Do value processing specific to the target field size.
4897 */
4898 cbDst = g_acbBs3Cg1DstFields[idxField];
4899 if (cbDst == BS3CG1DSTSIZE_OPERAND)
4900 cbDst = pThis->aOperands[idxField - BS3CG1DST_OP1].cbOp;
4901 else if (cbDst == BS3CG1DSTSIZE_OPERAND_SIZE_GRP)
4902 cbDst = pThis->cbOperand;
4903 if (cbDst <= 8)
4904 {
4905 unsigned const offField = g_aoffBs3Cg1DstFields[idxField];
4906
4907 /*
4908 * Deal with fields up to 8-byte wide.
4909 */
4910
4911 /* Get the value. */
4912 uint64_t uValue;
4913 if ((bOpcode & BS3CG1_CTXOP_SIGN_EXT))
4914 switch (cbValue)
4915 {
4916 case 1: uValue = *(int8_t const BS3_FAR *)pbCode; break;
4917 case 2: uValue = *(int16_t const BS3_FAR *)pbCode; break;
4918 case 4: uValue = *(int32_t const BS3_FAR *)pbCode; break;
4919 default:
4920 if (cbValue >= 8)
4921 {
4922 uValue = *(uint64_t const BS3_FAR *)pbCode;
4923 break;
4924 }
4925 return Bs3TestFailedF("Malformed context instruction: %u bytes value (%u dst)", cbValue, cbDst);
4926 }
4927 else
4928 switch (cbValue)
4929 {
4930 case 1: uValue = *(uint8_t const BS3_FAR *)pbCode; break;
4931 case 2: uValue = *(uint16_t const BS3_FAR *)pbCode; break;
4932 case 4: uValue = *(uint32_t const BS3_FAR *)pbCode; break;
4933 default:
4934 if (cbValue >= 8)
4935 {
4936 uValue = *(uint64_t const BS3_FAR *)pbCode;
4937 break;
4938 }
4939 return Bs3TestFailedF("Malformed context instruction: %u bytes value (%u dst)", cbValue, cbDst);
4940 }
4941
4942 /* Find the field. */
4943 if (offField < sizeof(BS3REGCTX))
4944 PtrField.pu8 = (uint8_t BS3_FAR *)pCtx + offField;
4945 /* Non-register operands: */
4946 else if ((unsigned)(idxField - BS3CG1DST_OP1) < 4U)
4947 {
4948 unsigned const idxOp = idxField - BS3CG1DST_OP1;
4949
4950 switch (pThis->aOperands[idxOp].enmLocation)
4951 {
4952 case BS3CG1OPLOC_IMM:
4953 if (pbInstr)
4954 PtrField.pu8 = &pbInstr[pThis->aOperands[idxOp].off];
4955 else
4956 return Bs3TestFailedF("Immediate operand referenced in output context!");
4957 break;
4958
4959 case BS3CG1OPLOC_MEM:
4960 if (!pbInstr)
4961 return Bs3TestFailedF("Read only operand specified in output!");
4962 PtrField.pu8 = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[idxOp].off];
4963 break;
4964
4965 case BS3CG1OPLOC_MEM_RW:
4966 case BS3CG1OPLOC_MEM_WO:
4967 if (pbInstr)
4968 {
4969 PtrField.pu8 = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[idxOp].off];
4970 pbMemCopy = pThis->MemOp.ab;
4971 }
4972 else
4973 PtrField.pu8 = pThis->MemOp.ab;
4974 break;
4975
4976 default:
4977 if (pThis->enmEncoding != pThis->enmEncodingNonInvalid)
4978 goto l_advance_to_next;
4979 return Bs3TestFailedF("Internal error: cbDst=%u idxField=%d (%d) offField=%#x: enmLocation=%u off=%#x idxField=%u",
4980 cbDst, idxField, idxOp, offField, pThis->aOperands[idxOp].enmLocation,
4981 pThis->aOperands[idxOp].off, pThis->aOperands[idxOp].idxField);
4982 }
4983 }
4984 /* Special field: Copying in undefined EFLAGS from the result context. */
4985 else if (idxField == BS3CG1DST_EFL_UNDEF)
4986 {
4987 if (!pEflCtx || (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK) != BS3CG1_CTXOP_ASSIGN)
4988 return Bs3TestFailed("Invalid BS3CG1DST_EFL_UNDEF usage");
4989 PtrField.pu32 = &pCtx->rflags.u32;
4990 uValue = (*PtrField.pu32 & ~(uint32_t)uValue) | (pEflCtx->rflags.u32 & (uint32_t)uValue);
4991 }
4992 /* Special field: Expected value (in/result) exception. */
4993 else if (idxField == BS3CG1DST_VALUE_XCPT)
4994 {
4995 if (!pEflCtx || (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK) != BS3CG1_CTXOP_ASSIGN || cbDst != 1)
4996 return Bs3TestFailed("Invalid BS3CG1DST_VALUE_XCPT usage");
4997 PtrField.pu8 = &pThis->bValueXcpt;
4998 }
4999 /* FPU and FXSAVE format. */
5000 else if ( pThis->pExtCtx->enmMethod != BS3EXTCTXMETHOD_ANCIENT
5001 && offField - sizeof(BS3REGCTX) < RT_UOFFSET_AFTER(BS3EXTCTX, Ctx.x87.aXMM[15]))
5002 {
5003 if (pThis->fWorkExtCtx)
5004 PtrField.pb = (uint8_t *)pThis->pExtCtx + offField - sizeof(BS3REGCTX);
5005 else if (!pThis->fCpuSetupFirstResult)
5006 {
5007 BS3CG1_DPRINTF(("dbg: Extended context disabled: skipping modification (<=8)\n"));
5008 goto l_advance_to_next;
5009 }
5010 else
5011 return Bs3TestFailedF("Extended context disabled: Field %d (%s) @ %#x LB %u\n",
5012 idxField, g_aszBs3Cg1DstFields[idxField].sz, offField, cbDst);
5013 }
5014 /** @todo other FPU fields and FPU state formats. */
5015 else
5016 return Bs3TestFailedF("Todo implement me: cbDst=%u idxField=%d %s offField=%#x (<= 8)",
5017 cbDst, idxField, g_aszBs3Cg1DstFields[idxField].sz, offField);
5018
5019#ifdef BS3CG1_DEBUG_CTX_MOD
5020 switch (cbDst)
5021 {
5022 case 1:
5023 BS3CG1_DPRINTF(("dbg: modify %s: %#04RX8 (LB %u) %s %#RX64 (LB %u)\n", g_aszBs3Cg1DstFields[idxField].sz,
5024 *PtrField.pu8, cbDst, Bs3Cg1CtxOpToString(bOpcode), uValue, cbValue));
5025 break;
5026 case 2:
5027 BS3CG1_DPRINTF(("dbg: modify %s: %#06RX16 (LB %u) %s %#RX64 (LB %u)\n", g_aszBs3Cg1DstFields[idxField].sz,
5028 *PtrField.pu16, cbDst, Bs3Cg1CtxOpToString(bOpcode), uValue, cbValue));
5029 break;
5030 case 4:
5031 BS3CG1_DPRINTF(("dbg: modify %s: %#010RX32 (LB %u) %s %#RX64 (LB %u)\n", g_aszBs3Cg1DstFields[idxField].sz,
5032 *PtrField.pu32, cbDst, Bs3Cg1CtxOpToString(bOpcode), uValue, cbValue));
5033 break;
5034 default:
5035 BS3CG1_DPRINTF(("dbg: modify %s: %#018RX64 (LB %u) %s %#RX64 (LB %u)\n", g_aszBs3Cg1DstFields[idxField].sz,
5036 *PtrField.pu64, cbDst, Bs3Cg1CtxOpToString(bOpcode), uValue, cbValue));
5037 break;
5038 }
5039#endif
5040
5041 /* Modify the field. */
5042 switch (cbDst)
5043 {
5044 case 1:
5045 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5046 {
5047 case BS3CG1_CTXOP_ASSIGN: *PtrField.pu8 = (uint8_t)uValue; break;
5048 case BS3CG1_CTXOP_OR: *PtrField.pu8 |= (uint8_t)uValue; break;
5049 case BS3CG1_CTXOP_AND: *PtrField.pu8 &= (uint8_t)uValue; break;
5050 case BS3CG1_CTXOP_AND_INV: *PtrField.pu8 &= ~(uint8_t)uValue; break;
5051 }
5052 break;
5053
5054 case 2:
5055 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5056 {
5057 case BS3CG1_CTXOP_ASSIGN: *PtrField.pu16 = (uint16_t)uValue; break;
5058 case BS3CG1_CTXOP_OR: *PtrField.pu16 |= (uint16_t)uValue; break;
5059 case BS3CG1_CTXOP_AND: *PtrField.pu16 &= (uint16_t)uValue; break;
5060 case BS3CG1_CTXOP_AND_INV: *PtrField.pu16 &= ~(uint16_t)uValue; break;
5061 }
5062 break;
5063
5064 case 4:
5065 if ( (unsigned)(idxField - BS3CG1DST_XMM0_DW0_ZX) <= (unsigned)(BS3CG1DST_XMM15_DW0_ZX - BS3CG1DST_XMM0_DW0_ZX)
5066 || fZxVlMax)
5067 {
5068 PtrField.pu32[1] = 0;
5069 PtrField.pu64[1] = 0;
5070 }
5071 else if (offField <= RT_UOFFSETOF(BS3REGCTX, r15) /* Clear the top dword. */)
5072 PtrField.pu32[1] = 0;
5073 else if ((unsigned)(idxField - BS3CG1DST_MM0_LO_ZX) <= (unsigned)(BS3CG1DST_MM7_LO_ZX - BS3CG1DST_MM0_LO_ZX))
5074 {
5075 PtrField.pu32[1] = 0;
5076 PtrField.pu32[2] = 0xffff; /* observed on skylake */
5077 }
5078 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5079 {
5080 case BS3CG1_CTXOP_ASSIGN: *PtrField.pu32 = (uint32_t)uValue; break;
5081 case BS3CG1_CTXOP_OR: *PtrField.pu32 |= (uint32_t)uValue; break;
5082 case BS3CG1_CTXOP_AND: *PtrField.pu32 &= (uint32_t)uValue; break;
5083 case BS3CG1_CTXOP_AND_INV: *PtrField.pu32 &= ~(uint32_t)uValue; break;
5084 }
5085 break;
5086
5087 case 8:
5088 if ( (unsigned)(idxField - BS3CG1DST_XMM0_LO_ZX) <= (unsigned)(BS3CG1DST_XMM15_LO_ZX - BS3CG1DST_XMM0_LO_ZX)
5089 || fZxVlMax)
5090 PtrField.pu64[1] = 0;
5091 else if ((unsigned)(idxField - BS3CG1DST_MM0) <= (unsigned)(BS3CG1DST_MM7 - BS3CG1DST_MM0))
5092 PtrField.pu32[2] = 0xffff; /* observed on skylake */
5093
5094 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5095 {
5096 case BS3CG1_CTXOP_ASSIGN: *PtrField.pu64 = (uint64_t)uValue; break;
5097 case BS3CG1_CTXOP_OR: *PtrField.pu64 |= (uint64_t)uValue; break;
5098 case BS3CG1_CTXOP_AND: *PtrField.pu64 &= (uint64_t)uValue; break;
5099 case BS3CG1_CTXOP_AND_INV: *PtrField.pu64 &= ~(uint64_t)uValue; break;
5100 }
5101 break;
5102
5103 default:
5104 return Bs3TestFailedF("Malformed context instruction: cbDst=%u, expected 1, 2, 4, or 8", cbDst);
5105 }
5106
5107#ifdef BS3CG1_DEBUG_CTX_MOD
5108 switch (cbDst)
5109 {
5110 case 1: BS3CG1_DPRINTF(("dbg: --> %s: %#04RX8\n", g_aszBs3Cg1DstFields[idxField].sz, *PtrField.pu8)); break;
5111 case 2: BS3CG1_DPRINTF(("dbg: --> %s: %#06RX16\n", g_aszBs3Cg1DstFields[idxField].sz, *PtrField.pu16)); break;
5112 case 4: BS3CG1_DPRINTF(("dbg: --> %s: %#010RX32\n", g_aszBs3Cg1DstFields[idxField].sz, *PtrField.pu32)); break;
5113 default: BS3CG1_DPRINTF(("dbg: --> %s: %#018RX64\n", g_aszBs3Cg1DstFields[idxField].sz, *PtrField.pu64)); break;
5114 }
5115#endif
5116 if (fZxVlMax)
5117 {
5118 uintptr_t iReg = ((uintptr_t)PtrField.pu8 - (uintptr_t)&pThis->pExtCtx->Ctx.x87.aXMM[0])
5119 / sizeof(pThis->pExtCtx->Ctx.x87.aXMM[0]);
5120 pThis->pExtCtx->Ctx.x.u.YmmHi.aYmmHi[iReg].au64[0] = 0;
5121 pThis->pExtCtx->Ctx.x.u.YmmHi.aYmmHi[iReg].au64[1] = 0;
5122#ifdef BS3CG1_DEBUG_CTX_MOD
5123 BS3CG1_DPRINTF(("dbg: --> cleared YMM%u_HI\n", iReg));
5124#endif
5125 }
5126 }
5127 /*
5128 * Deal with larger field (FPU, SSE, AVX, ...).
5129 */
5130 else if (pThis->fWorkExtCtx)
5131 {
5132 union
5133 {
5134 X86FPUREG FpuReg;
5135 X86XMMREG XmmReg;
5136 X86YMMREG YmmReg;
5137 X86ZMMREG ZmmReg;
5138 uint8_t ab[sizeof(X86ZMMREG)];
5139 uint32_t au32[sizeof(X86ZMMREG) / sizeof(uint32_t)];
5140 uint64_t au64[sizeof(X86ZMMREG) / sizeof(uint64_t)];
5141 } Value;
5142 unsigned const offField = g_aoffBs3Cg1DstFields[idxField];
5143 unsigned iReg;
5144
5145 /* Copy the value into the union, doing the zero padding / extending. */
5146 Bs3MemCpy(&Value, pbCode, cbValue);
5147 if (cbValue < sizeof(Value))
5148 {
5149 if ((bOpcode & BS3CG1_CTXOP_SIGN_EXT) && (Value.ab[cbValue - 1] & 0x80))
5150 Bs3MemSet(&Value.ab[cbValue], 0xff, sizeof(Value) - cbValue);
5151 else
5152 Bs3MemSet(&Value.ab[cbValue], 0x00, sizeof(Value) - cbValue);
5153 }
5154
5155 /* Optimized access to XMM and STx registers. */
5156 if ( pThis->pExtCtx->enmMethod != BS3EXTCTXMETHOD_ANCIENT
5157 && offField - sizeof(BS3REGCTX) < RT_UOFFSET_AFTER(BS3EXTCTX, Ctx.x87.aXMM[15]) )
5158 PtrField.pb = (uint8_t *)pThis->pExtCtx + offField - sizeof(BS3REGCTX);
5159 /* Non-register operands: */
5160 else if ((unsigned)(idxField - BS3CG1DST_OP1) < 4U)
5161 {
5162 unsigned const idxOp = idxField - BS3CG1DST_OP1;
5163 switch (pThis->aOperands[idxOp].enmLocation)
5164 {
5165 case BS3CG1OPLOC_MEM:
5166 if (!pbInstr)
5167 return Bs3TestFailedF("Read only operand specified in output!");
5168 PtrField.pu8 = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[idxOp].off];
5169 break;
5170
5171 case BS3CG1OPLOC_MEM_RW:
5172 case BS3CG1OPLOC_MEM_WO:
5173 if (pbInstr)
5174 {
5175 PtrField.pu8 = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[idxOp].off];
5176 pbMemCopy = pThis->MemOp.ab;
5177 }
5178 else
5179 PtrField.pu8 = pThis->MemOp.ab;
5180 break;
5181
5182 default:
5183 return Bs3TestFailedF("Internal error: Field %d (%d) @ %#x LB %u: enmLocation=%u off=%#x idxField=%u",
5184 idxField, idxOp, offField, cbDst, pThis->aOperands[idxOp].enmLocation,
5185 pThis->aOperands[idxOp].off, pThis->aOperands[idxOp].idxField);
5186 }
5187 }
5188 /* The YMM (AVX) registers have split storage in the state, so they need special handling. */
5189 else if ((iReg = idxField - BS3CG1DST_YMM0) < 16U)
5190 {
5191 /* The first 128-bits in XMM land. */
5192 PtrField.pu64 = &pThis->pExtCtx->Ctx.x87.aXMM[iReg].au64[0];
5193 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5194 {
5195 case BS3CG1_CTXOP_ASSIGN:
5196 PtrField.pu64[0] = Value.au64[0];
5197 PtrField.pu64[1] = Value.au64[1];
5198 break;
5199 case BS3CG1_CTXOP_OR:
5200 PtrField.pu64[0] |= Value.au64[0];
5201 PtrField.pu64[1] |= Value.au64[1];
5202 break;
5203 case BS3CG1_CTXOP_AND:
5204 PtrField.pu64[0] &= Value.au64[0];
5205 PtrField.pu64[1] &= Value.au64[1];
5206 break;
5207 case BS3CG1_CTXOP_AND_INV:
5208 PtrField.pu64[0] &= ~Value.au64[0];
5209 PtrField.pu64[1] &= ~Value.au64[1];
5210 break;
5211 }
5212
5213 /* The second 128-bit in YMM_HI land. */
5214 PtrField.pu64 = &pThis->pExtCtx->Ctx.x.u.YmmHi.aYmmHi[iReg].au64[0];
5215 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5216 {
5217 case BS3CG1_CTXOP_ASSIGN:
5218 PtrField.pu64[0] = Value.au64[2];
5219 PtrField.pu64[1] = Value.au64[3];
5220 break;
5221 case BS3CG1_CTXOP_OR:
5222 PtrField.pu64[0] |= Value.au64[2];
5223 PtrField.pu64[1] |= Value.au64[3];
5224 break;
5225 case BS3CG1_CTXOP_AND:
5226 PtrField.pu64[0] &= Value.au64[2];
5227 PtrField.pu64[1] &= Value.au64[3];
5228 break;
5229 case BS3CG1_CTXOP_AND_INV:
5230 PtrField.pu64[0] &= ~Value.au64[2];
5231 PtrField.pu64[1] &= ~Value.au64[3];
5232 break;
5233 }
5234 PtrField.pb = NULL;
5235 }
5236 /* AVX512 needs handling like above, but more complicated. */
5237 else
5238 return Bs3TestFailedF("TODO: implement me: cbDst=%d idxField=%d (AVX and other weird state)", cbDst, idxField);
5239
5240 if (PtrField.pb)
5241 {
5242 /* Modify the field / memory. */
5243 unsigned i;
5244 if (cbDst & 3)
5245 return Bs3TestFailedF("Malformed context instruction: cbDst=%u, multiple of 4", cbDst);
5246
5247#ifdef BS3CG1_DEBUG_CTX_MOD
5248 BS3CG1_DPRINTF(("dbg: modify %s: %.*Rhxs (LB %u) %s %.*Rhxs (LB %u)\n", g_aszBs3Cg1DstFields[idxField].sz,
5249 cbDst, PtrField.pb, cbDst, Bs3Cg1CtxOpToString(bOpcode), cbValue, Value.ab, cbValue));
5250#endif
5251
5252 i = cbDst / 4;
5253 while (i-- > 0)
5254 {
5255 switch (bOpcode & BS3CG1_CTXOP_OPERATOR_MASK)
5256 {
5257 case BS3CG1_CTXOP_ASSIGN: PtrField.pu32[i] = Value.au32[i]; break;
5258 case BS3CG1_CTXOP_OR: PtrField.pu32[i] |= Value.au32[i]; break;
5259 case BS3CG1_CTXOP_AND: PtrField.pu32[i] &= Value.au32[i]; break;
5260 case BS3CG1_CTXOP_AND_INV: PtrField.pu32[i] &= ~Value.au32[i]; break;
5261 }
5262 }
5263
5264#ifdef BS3CG1_DEBUG_CTX_MOD
5265 BS3CG1_DPRINTF(("dbg: --> %s: %.*Rhxs\n", g_aszBs3Cg1DstFields[idxField].sz, cbDst, PtrField.pb));
5266#endif
5267
5268 if (fZxVlMax)
5269 {
5270 uintptr_t iReg = ((uintptr_t)PtrField.pu8 - (uintptr_t)&pThis->pExtCtx->Ctx.x87.aXMM[0])
5271 / sizeof(pThis->pExtCtx->Ctx.x87.aXMM[0]);
5272 if (cbDst < 16)
5273 {
5274 for (i = cbDst / 4; i < 4; i++)
5275 PtrField.pu32[i++] = 0;
5276#ifdef BS3CG1_DEBUG_CTX_MOD
5277 BS3CG1_DPRINTF(("dbg: --> cleared high %u bytes of XMM%u\n", 16 - cbDst, iReg));
5278#endif
5279 }
5280 pThis->pExtCtx->Ctx.x.u.YmmHi.aYmmHi[iReg].au64[0] = 0;
5281 pThis->pExtCtx->Ctx.x.u.YmmHi.aYmmHi[iReg].au64[1] = 0;
5282#ifdef BS3CG1_DEBUG_CTX_MOD
5283 BS3CG1_DPRINTF(("dbg: --> cleared YMM%u_HI\n", iReg));
5284#endif
5285 }
5286 }
5287
5288 /*
5289 * Hack! Update pThis->MemOp when setting up the inputs so we can
5290 * correctly validate value and alignment exceptions.
5291 */
5292 if (pbMemCopy && PtrField.pv)
5293 Bs3MemCpy(pbMemCopy, PtrField.pv, cbDst);
5294 }
5295 /* !pThis->fWorkExtCtx: */
5296 else if (pThis->fCpuSetupFirstResult)
5297 return Bs3TestFailedF("Extended context disabled: Field %d (%s) @ %#x LB %u\n",
5298 idxField, g_aszBs3Cg1DstFields[idxField].sz, g_aoffBs3Cg1DstFields[idxField], cbDst);
5299 else
5300 BS3CG1_DPRINTF(("dbg: Extended context disabled: skipping modification [> 8]\n"));
5301
5302 /*
5303 * Advance to the next instruction.
5304 */
5305l_advance_to_next:
5306 pbCode += cbValue;
5307 cbLeft -= cbValue;
5308 }
5309
5310 return true;
5311}
5312
5313
5314/**
5315 * Checks the result of a run.
5316 *
5317 * @returns true if successful, false if not.
5318 * @param pThis The state.
5319 * @param bTestXcptExpected The exception causing the test code to stop
5320 * executing.
5321 * @param fInvalidEncodingPgFault Set if we've cut the instruction a byte
5322 * short and is expecting a \#PF on the page
5323 * boundrary rather than a \#UD. Only set if
5324 * fInvalidEncoding is also set.
5325 * @param iEncoding For error reporting.
5326 */
5327static bool BS3_NEAR_CODE Bs3Cg1CheckResult(PBS3CG1STATE pThis, uint8_t bTestXcptExpected,
5328 bool fInvalidEncodingPgFault, unsigned iEncoding)
5329{
5330 unsigned iOperand;
5331
5332 /*
5333 * Check the exception state first.
5334 */
5335 uint8_t bExpectedXcpt;
5336 uint8_t cbAdjustPc;
5337 if (!pThis->fInvalidEncoding)
5338 {
5339 bExpectedXcpt = pThis->bAlignmentXcpt;
5340 if (bExpectedXcpt == UINT8_MAX)
5341 bExpectedXcpt = pThis->bValueXcpt;
5342 if (bExpectedXcpt == UINT8_MAX)
5343 {
5344 cbAdjustPc = pThis->cbCurInstr;
5345 bExpectedXcpt = bTestXcptExpected;
5346 if (bTestXcptExpected == X86_XCPT_PF)
5347 pThis->Ctx.cr2.u = pThis->uCodePgFlat + X86_PAGE_SIZE;
5348 }
5349 else
5350 cbAdjustPc = 0;
5351 }
5352 else
5353 {
5354 cbAdjustPc = 0;
5355 if (!fInvalidEncodingPgFault)
5356 bExpectedXcpt = X86_XCPT_UD;
5357 else
5358 {
5359 bExpectedXcpt = X86_XCPT_PF;
5360 pThis->Ctx.cr2.u = pThis->uCodePgFlat + X86_PAGE_SIZE;
5361 }
5362 }
5363 if (RT_LIKELY( pThis->TrapFrame.bXcpt == bExpectedXcpt
5364 && pThis->TrapFrame.Ctx.rip.u == pThis->Ctx.rip.u + cbAdjustPc))
5365 {
5366 /*
5367 * Check the register content.
5368 */
5369 bool fOkay = Bs3TestCheckRegCtxEx(&pThis->TrapFrame.Ctx, &pThis->Ctx,
5370 cbAdjustPc, 0 /*cbSpAdjust*/, 0 /*fExtraEfl*/,
5371 pThis->pszMode, iEncoding);
5372
5373 /*
5374 * Check memory output operands.
5375 */
5376 if (!pThis->fInvalidEncoding)
5377 {
5378 iOperand = pThis->cOperands;
5379 while (iOperand-- > 0)
5380 if ( pThis->aOperands[iOperand].enmLocation == BS3CG1OPLOC_MEM_RW
5381 || pThis->aOperands[iOperand].enmLocation == BS3CG1OPLOC_MEM_WO)
5382 {
5383 if (pThis->aOperands[iOperand].off)
5384 {
5385 BS3PTRUNION PtrUnion;
5386 PtrUnion.pb = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[iOperand].off];
5387 switch (pThis->aOperands[iOperand].cbOp)
5388 {
5389 case 1:
5390 if (*PtrUnion.pu8 == pThis->MemOp.ab[0])
5391 continue;
5392 Bs3TestFailedF("op%u: Wrote %#04RX8, expected %#04RX8",
5393 iOperand, *PtrUnion.pu8, pThis->MemOp.ab[0]);
5394 break;
5395 case 2:
5396 if (*PtrUnion.pu16 == pThis->MemOp.au16[0])
5397 continue;
5398 Bs3TestFailedF("op%u: Wrote %#06RX16, expected %#06RX16",
5399 iOperand, *PtrUnion.pu16, pThis->MemOp.au16[0]);
5400 break;
5401 case 4:
5402 if (*PtrUnion.pu32 == pThis->MemOp.au32[0])
5403 continue;
5404 Bs3TestFailedF("op%u: Wrote %#010RX32, expected %#010RX32",
5405 iOperand, *PtrUnion.pu32, pThis->MemOp.au32[0]);
5406 break;
5407 case 8:
5408 if (*PtrUnion.pu64 == pThis->MemOp.au64[0])
5409 continue;
5410 Bs3TestFailedF("op%u: Wrote %#018RX64, expected %#018RX64",
5411 iOperand, *PtrUnion.pu64, pThis->MemOp.au64[0]);
5412 break;
5413 default:
5414 if (Bs3MemCmp(PtrUnion.pb, pThis->MemOp.ab, pThis->aOperands[iOperand].cbOp) == 0)
5415 continue;
5416 Bs3TestFailedF("op%u: Wrote %.*Rhxs, expected %.*Rhxs",
5417 iOperand,
5418 pThis->aOperands[iOperand].cbOp, PtrUnion.pb,
5419 pThis->aOperands[iOperand].cbOp, pThis->MemOp.ab);
5420 break;
5421 }
5422 }
5423 else
5424 Bs3TestFailedF("op%u: off is zero\n", iOperand);
5425 fOkay = false;
5426 }
5427 }
5428
5429 /*
5430 * Check extended context if enabled.
5431 */
5432 if (pThis->fWorkExtCtx)
5433 {
5434 PBS3EXTCTX pExpect = pThis->pExtCtx;
5435 PBS3EXTCTX pResult = pThis->pResultExtCtx;
5436 unsigned i;
5437 if ( pExpect->enmMethod == BS3EXTCTXMETHOD_XSAVE
5438 || pExpect->enmMethod == BS3EXTCTXMETHOD_FXSAVE)
5439 {
5440 /* Compare the x87 state, ASSUMING XCR0 bit 1 is set. */
5441#define CHECK_FIELD(a_Field, a_szFmt) \
5442 if (pResult->Ctx.a_Field != pExpect->Ctx.a_Field) fOkay = Bs3TestFailedF(a_szFmt, pResult->Ctx.a_Field, pExpect->Ctx.a_Field)
5443 CHECK_FIELD(x87.FCW, "FCW: %#06x, expected %#06x");
5444 CHECK_FIELD(x87.FSW, "FSW: %#06x, expected %#06x");
5445 CHECK_FIELD(x87.FTW, "FTW: %#06x, expected %#06x");
5446 //CHECK_FIELD(x87.FOP, "FOP: %#06x, expected %#06x");
5447 //CHECK_FIELD(x87.FPUIP, "FPUIP: %#010RX32, expected %#010RX32");
5448 //CHECK_FIELD(x87.CS, "FPUCS: %#06x, expected %#06x");
5449 //CHECK_FIELD(x87.Rsrvd1, "Rsrvd1: %#06x, expected %#06x");
5450 //CHECK_FIELD(x87.DP, "FPUDP: %#010RX32, expected %#010RX32");
5451 //CHECK_FIELD(x87.DS, "FPUDS: %#06x, expected %#06x");
5452 //CHECK_FIELD(x87.Rsrvd2, "Rsrvd2: %#06x, expected %#06x");
5453 CHECK_FIELD(x87.MXCSR, "MXCSR: %#010RX32, expected %#010RX32");
5454#undef CHECK_FIELD
5455 for (i = 0; i < RT_ELEMENTS(pExpect->Ctx.x87.aRegs); i++)
5456 if ( pResult->Ctx.x87.aRegs[i].au64[0] != pExpect->Ctx.x87.aRegs[i].au64[0]
5457 || pResult->Ctx.x87.aRegs[i].au16[4] != pExpect->Ctx.x87.aRegs[i].au16[4])
5458 fOkay = Bs3TestFailedF("ST[%u]: %c m=%#RX64 e=%d, expected %c m=%#RX64 e=%d", i,
5459 pResult->Ctx.x87.aRegs[i].r80Ex.s.fSign ? '-' : '+',
5460 pResult->Ctx.x87.aRegs[i].r80Ex.s.u64Mantissa,
5461 pResult->Ctx.x87.aRegs[i].r80Ex.s.uExponent,
5462 pExpect->Ctx.x87.aRegs[i].r80Ex.s.fSign ? '-' : '+',
5463 pExpect->Ctx.x87.aRegs[i].r80Ex.s.u64Mantissa,
5464 pExpect->Ctx.x87.aRegs[i].r80Ex.s.uExponent);
5465 for (i = 0; i < (ARCH_BITS == 64 ? 16 : 8); i++)
5466 if ( pResult->Ctx.x87.aXMM[i].au64[0] != pExpect->Ctx.x87.aXMM[i].au64[0]
5467 || pResult->Ctx.x87.aXMM[i].au64[1] != pExpect->Ctx.x87.aXMM[i].au64[1])
5468 fOkay = Bs3TestFailedF("XMM%u: %#010RX64'%016RX64, expected %#010RX64'%08RX64", i,
5469 pResult->Ctx.x87.aXMM[i].au64[1],
5470 pResult->Ctx.x87.aXMM[i].au64[0],
5471 pExpect->Ctx.x87.aXMM[i].au64[1],
5472 pExpect->Ctx.x87.aXMM[i].au64[0]);
5473 if (pExpect->fXcr0Saved & XSAVE_C_YMM)
5474 for (i = 0; i < (ARCH_BITS == 64 ? 16 : 8); i++)
5475 if ( pResult->Ctx.x.u.YmmHi.aYmmHi[i].au64[0] != pExpect->Ctx.x.u.YmmHi.aYmmHi[i].au64[0]
5476 || pResult->Ctx.x.u.YmmHi.aYmmHi[i].au64[1] != pExpect->Ctx.x.u.YmmHi.aYmmHi[i].au64[1])
5477 fOkay = Bs3TestFailedF("YMM%u_HI: %#010RX64'%016RX64, expected %#010RX64'%08RX64", i,
5478 pResult->Ctx.x.u.YmmHi.aYmmHi[i].au64[1],
5479 pResult->Ctx.x.u.YmmHi.aYmmHi[i].au64[0],
5480 pExpect->Ctx.x.u.YmmHi.aYmmHi[i].au64[1],
5481 pExpect->Ctx.x.u.YmmHi.aYmmHi[i].au64[0]);
5482 }
5483 else
5484 fOkay = Bs3TestFailedF("Unsupported extended CPU context method: %d", pExpect->enmMethod);
5485 }
5486
5487 /*
5488 * Done.
5489 */
5490 if (fOkay)
5491 return true;
5492
5493 /*
5494 * Report failure.
5495 */
5496 Bs3TestFailedF("ins#%RU32/test#%u: encoding #%u: %.*Rhxs%s",
5497 pThis->iInstr, pThis->iTest, iEncoding, pThis->cbCurInstr, pThis->abCurInstr,
5498 fInvalidEncodingPgFault ? " (cut short)" : "");
5499 }
5500 else
5501 Bs3TestFailedF("ins#%RU32/test#%u: bXcpt=%#x expected %#x; rip=%RX64 expected %RX64; encoding#%u: %.*Rhxs%s",
5502 pThis->iInstr, pThis->iTest,
5503 pThis->TrapFrame.bXcpt, bExpectedXcpt,
5504 pThis->TrapFrame.Ctx.rip.u, pThis->Ctx.rip.u + cbAdjustPc,
5505 iEncoding, pThis->cbCurInstr, pThis->abCurInstr, fInvalidEncodingPgFault ? " (cut short)" : "");
5506 Bs3TestPrintf("cpl=%u cbOperands=%u\n", pThis->uCpl, pThis->cbOperand);
5507
5508 /*
5509 * Display memory operands.
5510 */
5511 for (iOperand = 0; iOperand < pThis->cOperands; iOperand++)
5512 {
5513 BS3PTRUNION PtrUnion;
5514 switch (pThis->aOperands[iOperand].enmLocation)
5515 {
5516 case BS3CG1OPLOC_CTX:
5517 {
5518 uint8_t idxField = pThis->aOperands[iOperand].idxField;
5519 unsigned offField = g_aoffBs3Cg1DstFields[idxField];
5520 if (offField <= sizeof(BS3REGCTX))
5521 PtrUnion.pb = (uint8_t BS3_FAR *)&pThis->Ctx + offField;
5522 else
5523 {
5524 Bs3TestPrintf("op%u: ctx%u: xxxx\n", iOperand, pThis->aOperands[iOperand].cbOp * 8);
5525 break;
5526 }
5527 switch (pThis->aOperands[iOperand].cbOp)
5528 {
5529 case 1: Bs3TestPrintf("op%u: ctx08: %#04RX8\n", iOperand, *PtrUnion.pu8); break;
5530 case 2: Bs3TestPrintf("op%u: ctx16: %#06RX16\n", iOperand, *PtrUnion.pu16); break;
5531 case 4: Bs3TestPrintf("op%u: ctx32: %#010RX32\n", iOperand, *PtrUnion.pu32); break;
5532 case 8: Bs3TestPrintf("op%u: ctx64: %#018RX64\n", iOperand, *PtrUnion.pu64); break;
5533 default:
5534 Bs3TestPrintf("op%u: ctx%u: %.*Rhxs\n", iOperand, pThis->aOperands[iOperand].cbOp * 8,
5535 pThis->aOperands[iOperand].cbOp, PtrUnion.pb);
5536 break;
5537 }
5538 break;
5539 }
5540
5541 case BS3CG1OPLOC_IMM:
5542 PtrUnion.pb = &pThis->pbCodePg[pThis->aOperands[iOperand].off];
5543 switch (pThis->aOperands[iOperand].cbOp)
5544 {
5545 case 1: Bs3TestPrintf("op%u: imm08: %#04RX8\n", iOperand, *PtrUnion.pu8); break;
5546 case 2: Bs3TestPrintf("op%u: imm16: %#06RX16\n", iOperand, *PtrUnion.pu16); break;
5547 case 4: Bs3TestPrintf("op%u: imm32: %#010RX32\n", iOperand, *PtrUnion.pu32); break;
5548 case 8: Bs3TestPrintf("op%u: imm64: %#018RX64\n", iOperand, *PtrUnion.pu64); break;
5549 default:
5550 Bs3TestPrintf("op%u: imm%u: %.*Rhxs\n", iOperand, pThis->aOperands[iOperand].cbOp * 8,
5551 pThis->aOperands[iOperand].cbOp, PtrUnion.pb);
5552 break;
5553 }
5554 break;
5555
5556 case BS3CG1OPLOC_MEM:
5557 case BS3CG1OPLOC_MEM_RW:
5558 case BS3CG1OPLOC_MEM_WO:
5559 if (pThis->aOperands[iOperand].off)
5560 {
5561 PtrUnion.pb = &pThis->pbDataPg[X86_PAGE_SIZE - pThis->aOperands[iOperand].off];
5562 switch (pThis->aOperands[iOperand].cbOp)
5563 {
5564 case 1: Bs3TestPrintf("op%u: result mem08: %#04RX8\n", iOperand, *PtrUnion.pu8); break;
5565 case 2: Bs3TestPrintf("op%u: result mem16: %#06RX16\n", iOperand, *PtrUnion.pu16); break;
5566 case 4: Bs3TestPrintf("op%u: result mem32: %#010RX32\n", iOperand, *PtrUnion.pu32); break;
5567 case 8: Bs3TestPrintf("op%u: result mem64: %#018RX64\n", iOperand, *PtrUnion.pu64); break;
5568 default:
5569 Bs3TestPrintf("op%u: result mem%u: %.*Rhxs\n", iOperand, pThis->aOperands[iOperand].cbOp * 8,
5570 pThis->aOperands[iOperand].cbOp, PtrUnion.pb);
5571 break;
5572 }
5573 if ( pThis->aOperands[iOperand].enmLocation == BS3CG1OPLOC_MEM_WO
5574 || pThis->aOperands[iOperand].enmLocation == BS3CG1OPLOC_MEM_RW)
5575 {
5576 PtrUnion.pb = pThis->MemOp.ab;
5577 switch (pThis->aOperands[iOperand].cbOp)
5578 {
5579 case 1: Bs3TestPrintf("op%u: expect mem08: %#04RX8\n", iOperand, *PtrUnion.pu8); break;
5580 case 2: Bs3TestPrintf("op%u: expect mem16: %#06RX16\n", iOperand, *PtrUnion.pu16); break;
5581 case 4: Bs3TestPrintf("op%u: expect mem32: %#010RX32\n", iOperand, *PtrUnion.pu32); break;
5582 case 8: Bs3TestPrintf("op%u: expect mem64: %#018RX64\n", iOperand, *PtrUnion.pu64); break;
5583 default:
5584 Bs3TestPrintf("op%u: expect mem%u: %.*Rhxs\n", iOperand, pThis->aOperands[iOperand].cbOp * 8,
5585 pThis->aOperands[iOperand].cbOp, PtrUnion.pb);
5586 break;
5587 }
5588 }
5589 }
5590 else
5591 Bs3TestPrintf("op%u: mem%u: zero off value!!\n", iOperand, pThis->aOperands[iOperand].cbOp * 8);
5592 break;
5593 }
5594 }
5595
5596 /*
5597 * Display contexts.
5598 */
5599 Bs3TestPrintf("-- Expected context:\n");
5600 Bs3RegCtxPrint(&pThis->Ctx);
5601 if (pThis->fWorkExtCtx)
5602 Bs3TestPrintf("xcr0=%RX64\n", pThis->pExtCtx->fXcr0Saved);
5603 Bs3TestPrintf("-- Actual context:\n");
5604 Bs3TrapPrintFrame(&pThis->TrapFrame);
5605 if (pThis->fWorkExtCtx)
5606 Bs3TestPrintf("xcr0=%RX64\n", pThis->pResultExtCtx->fXcr0Saved);
5607 Bs3TestPrintf("\n");
5608ASMHalt();
5609 return false;
5610}
5611
5612
5613/**
5614 * Destroys the state, freeing all allocations and such.
5615 *
5616 * @param pThis The state.
5617 */
5618static void BS3_NEAR_CODE Bs3Cg1Destroy(PBS3CG1STATE pThis)
5619{
5620 if (BS3_MODE_IS_PAGED(pThis->bMode))
5621 {
5622#if ARCH_BITS != 16
5623 Bs3MemGuardedTestPageFree(pThis->pbCodePg);
5624 Bs3MemGuardedTestPageFree(pThis->pbDataPg);
5625#endif
5626 }
5627 else
5628 {
5629 Bs3MemFree(pThis->pbCodePg, X86_PAGE_SIZE);
5630 Bs3MemFree(pThis->pbDataPg, X86_PAGE_SIZE);
5631 }
5632
5633 if (pThis->pExtCtx)
5634 Bs3MemFree(pThis->pExtCtx, pThis->pExtCtx->cb * 3);
5635
5636 pThis->pbCodePg = NULL;
5637 pThis->pbDataPg = NULL;
5638 pThis->pExtCtx = NULL;
5639 pThis->pResultExtCtx = NULL;
5640 pThis->pInitialExtCtx = NULL;
5641}
5642
5643
5644/**
5645 * Initializes the state.
5646 *
5647 * @returns Success indicator (true/false)
5648 * @param pThis The state.
5649 * @param bMode The mode being tested.
5650 */
5651bool BS3_NEAR_CODE BS3_CMN_NM(Bs3Cg1Init)(PBS3CG1STATE pThis, uint8_t bMode)
5652{
5653 BS3MEMKIND const enmMemKind = BS3_MODE_IS_RM_OR_V86(bMode) ? BS3MEMKIND_REAL
5654 : !BS3_MODE_IS_64BIT_CODE(bMode) ? BS3MEMKIND_TILED : BS3MEMKIND_FLAT32;
5655 unsigned iRing;
5656 unsigned cb;
5657 unsigned i;
5658 uint64_t fFlags;
5659 PBS3EXTCTX pExtCtx;
5660
5661 Bs3MemSet(pThis, 0, sizeof(*pThis));
5662
5663 pThis->iFirstRing = BS3_MODE_IS_V86(bMode) ? 3 : 0;
5664 pThis->iEndRing = BS3_MODE_IS_RM_SYS(bMode) ? 1 : 4;
5665 pThis->bMode = bMode;
5666 pThis->pszMode = Bs3GetModeName(bMode);
5667 pThis->pszModeShort = Bs3GetModeNameShortLower(bMode);
5668 pThis->bCpuVendor = Bs3GetCpuVendor();
5669 pThis->pchMnemonic = g_achBs3Cg1Mnemonics;
5670 pThis->pabOperands = g_abBs3Cg1Operands;
5671 pThis->pabOpcodes = g_abBs3Cg1Opcodes;
5672 pThis->fAdvanceMnemonic = 1;
5673
5674 /* Allocate extended context structures. */
5675 cb = Bs3ExtCtxGetSize(&fFlags);
5676 pExtCtx = Bs3MemAlloc(BS3MEMKIND_TILED, cb * 3);
5677 if (!pExtCtx)
5678 return Bs3TestFailedF("Bs3MemAlloc(tiled,%#x)", cb * 3);
5679 pThis->pExtCtx = pExtCtx;
5680 pThis->pResultExtCtx = (PBS3EXTCTX)((uint8_t BS3_FAR *)pExtCtx + cb);
5681 pThis->pInitialExtCtx = (PBS3EXTCTX)((uint8_t BS3_FAR *)pExtCtx + cb + cb);
5682
5683 Bs3ExtCtxInit(pThis->pExtCtx, cb, fFlags);
5684 Bs3ExtCtxInit(pThis->pResultExtCtx, cb, fFlags);
5685 Bs3ExtCtxInit(pThis->pInitialExtCtx, cb, fFlags);
5686 //Bs3TestPrintf("fCR0=%RX64 cbExtCtx=%#x method=%d\n", fFlags, cb, pExtCtx->enmMethod);
5687
5688 /* Allocate guarded exectuable and data memory. */
5689 if (BS3_MODE_IS_PAGED(bMode))
5690 {
5691#if ARCH_BITS != 16
5692 pThis->pbCodePg = Bs3MemGuardedTestPageAlloc(enmMemKind);
5693 pThis->pbDataPg = Bs3MemGuardedTestPageAlloc(enmMemKind);
5694 if (!pThis->pbCodePg || !pThis->pbDataPg)
5695 {
5696 Bs3TestFailedF("Bs3MemGuardedTestPageAlloc(%d) failed", enmMemKind);
5697 Bs3MemPrintInfo();
5698 Bs3Shutdown();
5699 return Bs3TestFailedF("Bs3MemGuardedTestPageAlloc(%d) failed", enmMemKind);
5700 }
5701 if ( BS3_MODE_IS_64BIT_CODE(bMode)
5702 && (uintptr_t)pThis->pbDataPg >= _2G)
5703 return Bs3TestFailedF("pbDataPg=%p is above 2GB and not simple to address from 64-bit code", pThis->pbDataPg);
5704#else
5705 return Bs3TestFailed("WTF?! #1");
5706#endif
5707 }
5708 else
5709 {
5710 pThis->pbCodePg = Bs3MemAlloc(enmMemKind, X86_PAGE_SIZE);
5711 pThis->pbDataPg = Bs3MemAlloc(enmMemKind, X86_PAGE_SIZE);
5712 if (!pThis->pbCodePg || !pThis->pbDataPg)
5713 {
5714 Bs3MemPrintInfo();
5715 return Bs3TestFailedF("Bs3MemAlloc(%d,Pg) failed", enmMemKind);
5716 }
5717 }
5718 pThis->uCodePgFlat = Bs3SelPtrToFlat(pThis->pbCodePg);
5719 pThis->uDataPgFlat = Bs3SelPtrToFlat(pThis->pbDataPg);
5720#if ARCH_BITS == 16
5721 pThis->CodePgFar.sel = BS3_FP_SEG(pThis->pbCodePg);
5722 pThis->CodePgFar.off = BS3_FP_OFF(pThis->pbCodePg);
5723 pThis->CodePgRip = BS3_FP_OFF(pThis->pbCodePg);
5724 pThis->DataPgFar.sel = BS3_FP_SEG(pThis->pbDataPg);
5725 pThis->DataPgFar.off = BS3_FP_OFF(pThis->pbDataPg);
5726#else
5727 if (BS3_MODE_IS_RM_OR_V86(bMode))
5728 {
5729 *(uint32_t *)&pThis->DataPgFar = Bs3SelFlatDataToRealMode(pThis->uDataPgFlat);
5730 ASMCompilerBarrier();
5731 pThis->CodePgFar.off = 0;
5732 pThis->CodePgFar.sel = pThis->uCodePgFlat >> 4;
5733 pThis->CodePgRip = pThis->CodePgFar.off;
5734 }
5735 else if (BS3_MODE_IS_16BIT_CODE(bMode))
5736 {
5737 *(uint32_t *)&pThis->DataPgFar = Bs3SelFlatDataToProtFar16(pThis->uDataPgFlat);
5738 ASMCompilerBarrier();
5739 pThis->CodePgFar.sel = BS3_SEL_SPARE_00;
5740 pThis->CodePgFar.off = 0;
5741 pThis->CodePgRip = 0;
5742 }
5743 else if (BS3_MODE_IS_32BIT_CODE(bMode))
5744 {
5745 *(uint32_t *)&pThis->DataPgFar = Bs3SelFlatDataToProtFar16(pThis->uDataPgFlat);
5746 ASMCompilerBarrier();
5747 pThis->CodePgFar.sel = 0;
5748 pThis->CodePgFar.off = 0;
5749 pThis->CodePgRip = (uintptr_t)pThis->pbCodePg;
5750 }
5751 else
5752 {
5753 pThis->DataPgFar.off = 0;
5754 pThis->DataPgFar.sel = 0;
5755 pThis->CodePgFar.off = 0;
5756 pThis->CodePgFar.sel = 0;
5757 pThis->CodePgRip = (uintptr_t)pThis->pbCodePg;
5758 }
5759#endif
5760 BS3CG1_DPRINTF(("pbDataPg=%p %04x:%04x pbCodePg=%p %04x:%04x\n",
5761 pThis->pbDataPg, pThis->DataPgFar.sel, pThis->DataPgFar.off,
5762 pThis->pbCodePg, pThis->CodePgFar.sel, pThis->CodePgFar.off));
5763
5764 /*
5765 * Create basic context for each target ring.
5766 *
5767 * In protected 16-bit code we need set up code selectors that can access
5768 * pbCodePg.
5769 *
5770 * In long mode we make sure the high 32-bits of GPRs (sans RSP) have some
5771 * bits set so we can check that the implicit clearing is tested.
5772 */
5773 Bs3RegCtxSaveEx(&pThis->aInitialCtxs[pThis->iFirstRing], bMode, 1024 * 3);
5774#if ARCH_BITS == 64
5775 pThis->aInitialCtxs[pThis->iFirstRing].rax.u |= UINT64_C(0x0101010100000000);
5776 pThis->aInitialCtxs[pThis->iFirstRing].rbx.u |= UINT64_C(0x0202020200000000);
5777 pThis->aInitialCtxs[pThis->iFirstRing].rcx.u |= UINT64_C(0x0303030300000000);
5778 pThis->aInitialCtxs[pThis->iFirstRing].rdx.u |= UINT64_C(0x0404040400000000);
5779 pThis->aInitialCtxs[pThis->iFirstRing].rbp.u |= UINT64_C(0x0505050500000000);
5780 pThis->aInitialCtxs[pThis->iFirstRing].rdi.u |= UINT64_C(0x0606060600000000);
5781 pThis->aInitialCtxs[pThis->iFirstRing].rsi.u |= UINT64_C(0x0707070700000000);
5782 pThis->aInitialCtxs[pThis->iFirstRing].r8.u |= UINT64_C(0x0808080800000000);
5783 pThis->aInitialCtxs[pThis->iFirstRing].r9.u |= UINT64_C(0x0909090900000000);
5784 pThis->aInitialCtxs[pThis->iFirstRing].r10.u |= UINT64_C(0x1010101000000000);
5785 pThis->aInitialCtxs[pThis->iFirstRing].r11.u |= UINT64_C(0x1111111100000000);
5786 pThis->aInitialCtxs[pThis->iFirstRing].r12.u |= UINT64_C(0x1212121200000000);
5787 pThis->aInitialCtxs[pThis->iFirstRing].r13.u |= UINT64_C(0x1313131300000000);
5788 pThis->aInitialCtxs[pThis->iFirstRing].r14.u |= UINT64_C(0x1414141400000000);
5789 pThis->aInitialCtxs[pThis->iFirstRing].r15.u |= UINT64_C(0x1515151500000000);
5790#endif
5791
5792 if (BS3_MODE_IS_RM_OR_V86(bMode))
5793 {
5794 pThis->aInitialCtxs[pThis->iFirstRing].cs = pThis->CodePgFar.sel;
5795 BS3_ASSERT(pThis->iFirstRing + 1 == pThis->iEndRing);
5796 }
5797 else if (BS3_MODE_IS_16BIT_CODE(bMode))
5798 {
5799#if ARCH_BITS == 16
5800 uintptr_t const uFlatCodePgSeg = Bs3SelPtrToFlat(BS3_FP_MAKE(BS3_FP_SEG(pThis->pbCodePg), 0));
5801#else
5802 uintptr_t const uFlatCodePgSeg = (uintptr_t)pThis->pbCodePg;
5803#endif
5804 for (iRing = pThis->iFirstRing + 1; iRing < pThis->iEndRing; iRing++)
5805 {
5806 Bs3MemCpy(&pThis->aInitialCtxs[iRing], &pThis->aInitialCtxs[pThis->iFirstRing], sizeof(pThis->aInitialCtxs[iRing]));
5807 Bs3RegCtxConvertToRingX(&pThis->aInitialCtxs[iRing], iRing);
5808 }
5809 for (iRing = pThis->iFirstRing; iRing < pThis->iEndRing; iRing++)
5810 {
5811 pThis->aInitialCtxs[iRing].cs = BS3_SEL_SPARE_00 + iRing * 8 + iRing;
5812 Bs3SelSetup16BitCode(&Bs3GdteSpare00 + iRing, uFlatCodePgSeg, iRing);
5813 }
5814 }
5815 else
5816 {
5817 Bs3RegCtxSetRipCsFromCurPtr(&pThis->aInitialCtxs[pThis->iFirstRing], (FPFNBS3FAR)pThis->pbCodePg);
5818 for (iRing = pThis->iFirstRing + 1; iRing < pThis->iEndRing; iRing++)
5819 {
5820 Bs3MemCpy(&pThis->aInitialCtxs[iRing], &pThis->aInitialCtxs[pThis->iFirstRing], sizeof(pThis->aInitialCtxs[iRing]));
5821 Bs3RegCtxConvertToRingX(&pThis->aInitialCtxs[iRing], iRing);
5822 }
5823 }
5824
5825 /*
5826 * Create an initial extended CPU context.
5827 */
5828 pExtCtx = pThis->pInitialExtCtx;
5829 if ( pExtCtx->enmMethod == BS3EXTCTXMETHOD_FXSAVE
5830 || pExtCtx->enmMethod == BS3EXTCTXMETHOD_XSAVE)
5831 {
5832 pExtCtx->Ctx.x87.FCW = X86_FCW_MASK_ALL | X86_FCW_PC_64 | X86_FCW_RC_NEAREST;
5833 pExtCtx->Ctx.x87.FSW = 0;
5834 pExtCtx->Ctx.x87.MXCSR = X86_MXCSR_IM | X86_MXCSR_DM | X86_MXCSR_RC_NEAREST;
5835 pExtCtx->Ctx.x87.MXCSR_MASK = 0;
5836 for (i = 0; i < RT_ELEMENTS(pExtCtx->Ctx.x87.aRegs); i++)
5837 {
5838 pExtCtx->Ctx.x87.aRegs[i].au16[0] = i << 4;
5839 pExtCtx->Ctx.x87.aRegs[i].au16[1] = i << 4;
5840 pExtCtx->Ctx.x87.aRegs[i].au16[2] = i << 4;
5841 pExtCtx->Ctx.x87.aRegs[i].au16[3] = i << 4;
5842 }
5843 for (i = 0; i < RT_ELEMENTS(pExtCtx->Ctx.x87.aXMM); i++)
5844 {
5845 pExtCtx->Ctx.x87.aXMM[i].au16[0] = i | UINT16_C(0x8f00);
5846 pExtCtx->Ctx.x87.aXMM[i].au16[1] = i | UINT16_C(0x8e00);
5847 pExtCtx->Ctx.x87.aXMM[i].au16[2] = i | UINT16_C(0x8d00);
5848 pExtCtx->Ctx.x87.aXMM[i].au16[3] = i | UINT16_C(0x8c00);
5849 pExtCtx->Ctx.x87.aXMM[i].au16[4] = i | UINT16_C(0x8b00);
5850 pExtCtx->Ctx.x87.aXMM[i].au16[5] = i | UINT16_C(0x8a00);
5851 pExtCtx->Ctx.x87.aXMM[i].au16[6] = i | UINT16_C(0x8900);
5852 pExtCtx->Ctx.x87.aXMM[i].au16[7] = i | UINT16_C(0x8800);
5853 }
5854 if (pExtCtx->fXcr0Nominal & XSAVE_C_YMM)
5855 for (i = 0; i < RT_ELEMENTS(pExtCtx->Ctx.x.u.YmmHi.aYmmHi); i++)
5856 {
5857 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[0] = (i << 8) | (i << 12) | 0xff;
5858 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[1] = (i << 8) | (i << 12) | 0xfe;
5859 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[2] = (i << 8) | (i << 12) | 0xfd;
5860 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[3] = (i << 8) | (i << 12) | 0xfc;
5861 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[4] = (i << 8) | (i << 12) | 0xfb;
5862 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[5] = (i << 8) | (i << 12) | 0xfa;
5863 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[6] = (i << 8) | (i << 12) | 0xf9;
5864 pExtCtx->Ctx.x.u.YmmHi.aYmmHi[i].au16[7] = (i << 8) | (i << 12) | 0xf8;
5865 }
5866
5867 }
5868 //else if (pExtCtx->enmMethod == BS3EXTCTXMETHOD_ANCIENT)
5869 else
5870 return Bs3TestFailedF("Unsupported extended CPU context method: %d", pExtCtx->enmMethod);
5871
5872 return true;
5873}
5874
5875
5876static uint8_t BS3_NEAR_CODE BS3_CMN_NM(Bs3Cg1WorkerInner)(PBS3CG1STATE pThis)
5877{
5878 uint8_t iRing;
5879 unsigned iInstr;
5880
5881 /*
5882 * Test the instructions.
5883 */
5884 for (iInstr = 0; iInstr < g_cBs3Cg1Instructions;
5885 iInstr++,
5886 pThis->pchMnemonic += pThis->fAdvanceMnemonic * pThis->cchMnemonic,
5887 pThis->pabOperands += pThis->cOperands,
5888 pThis->pabOpcodes += pThis->cbOpcodes)
5889 {
5890 uint8_t const bTestXcptExpected = BS3_MODE_IS_PAGED(pThis->bMode) ? X86_XCPT_PF : X86_XCPT_UD;
5891 bool fOuterInvalidInstr = false;
5892 unsigned iCpuSetup;
5893
5894 /*
5895 * Expand the instruction information into the state.
5896 * Note! 16-bit will switch to a two level test header lookup once we exceed 64KB.
5897 */
5898 PCBS3CG1INSTR pInstr = &g_aBs3Cg1Instructions[iInstr];
5899 pThis->iInstr = iInstr;
5900 pThis->pTestHdr = (PCBS3CG1TESTHDR)&g_abBs3Cg1Tests[pInstr->offTests];
5901 pThis->fFlags = pInstr->fFlags;
5902 pThis->enmEncoding = (BS3CG1ENC)pInstr->enmEncoding;
5903 pThis->enmEncodingNonInvalid = (BS3CG1ENC)pInstr->enmEncoding;
5904 pThis->enmCpuTest = (BS3CG1CPU)pInstr->enmCpuTest;
5905 pThis->enmPrefixKind = (BS3CG1PFXKIND)pInstr->enmPrefixKind;
5906 pThis->enmXcptType = (BS3CG1XCPTTYPE)pInstr->enmXcptType;
5907 pThis->cchMnemonic = pInstr->cchMnemonic;
5908 if (pThis->fAdvanceMnemonic)
5909 Bs3TestSubF("%s / %.*s", pThis->pszModeShort, pThis->cchMnemonic, pThis->pchMnemonic);
5910 pThis->fAdvanceMnemonic = pInstr->fAdvanceMnemonic;
5911 pThis->uOpcodeMap = pInstr->uOpcodeMap;
5912 pThis->cOperands = pInstr->cOperands;
5913 pThis->cbOpcodes = pInstr->cbOpcodes;
5914 switch (pThis->cOperands)
5915 {
5916 case 4: pThis->aenmOperands[3] = (BS3CG1OP)pThis->pabOperands[3];
5917 case 3: pThis->aenmOperands[2] = (BS3CG1OP)pThis->pabOperands[2];
5918 case 2: pThis->aenmOperands[1] = (BS3CG1OP)pThis->pabOperands[1];
5919 case 1: pThis->aenmOperands[0] = (BS3CG1OP)pThis->pabOperands[0];
5920 }
5921 switch (pThis->cbOpcodes)
5922 {
5923 case 4: pThis->abOpcodes[3] = pThis->pabOpcodes[3];
5924 case 3: pThis->abOpcodes[2] = pThis->pabOpcodes[2];
5925 case 2: pThis->abOpcodes[1] = pThis->pabOpcodes[1];
5926 case 1: pThis->abOpcodes[0] = pThis->pabOpcodes[0];
5927 }
5928
5929 /*
5930 * Check if the CPU supports the instruction.
5931 */
5932 pThis->fCpuSetupFirstResult = Bs3Cg1CpuSetupFirst(pThis);
5933 if ( !pThis->fCpuSetupFirstResult
5934 || (pThis->fFlags & (BS3CG1INSTR_F_UNUSED | BS3CG1INSTR_F_INVALID)))
5935 fOuterInvalidInstr = true;
5936
5937 /* Switch the encoder for some of the invalid instructions on non-intel CPUs. */
5938 if ( (pThis->fFlags & BS3CG1INSTR_F_INTEL_DECODES_INVALID)
5939 && pThis->bCpuVendor != BS3CPUVENDOR_INTEL
5940 && ( (pThis->fFlags & (BS3CG1INSTR_F_UNUSED | BS3CG1INSTR_F_INVALID))
5941 || (BS3CG1_IS_64BIT_TARGET(pThis) && (pThis->fFlags & BS3CG1INSTR_F_INVALID_64BIT))
5942 || fOuterInvalidInstr ) )
5943 pThis->enmEncoding = Bs3Cg1CalcNoneIntelInvalidEncoding(pThis->enmEncoding);
5944
5945 for (iCpuSetup = 0;; iCpuSetup++)
5946 {
5947 unsigned iEncoding;
5948 unsigned iEncodingNext;
5949
5950 /*
5951 * Prep the operands and encoding handling.
5952 */
5953 Bs3Cg1SetOpSizes(pThis, pThis->bMode);
5954 if (!Bs3Cg1EncodePrep(pThis))
5955 break;
5956
5957 /*
5958 * Encode the instruction in various ways and check out the test values.
5959 */
5960 for (iEncoding = 0;; iEncoding = iEncodingNext)
5961 {
5962 /*
5963 * Encode the next instruction variation.
5964 */
5965 pThis->fInvalidEncoding = fOuterInvalidInstr;
5966 iEncodingNext = Bs3Cg1EncodeNext(pThis, iEncoding);
5967 if (iEncodingNext <= iEncoding)
5968 break;
5969 BS3CG1_DPRINTF(("\ndbg: Encoding #%u: cbCurInst=%u: %.*Rhxs fInvalidEncoding=%d\n",
5970 iEncoding, pThis->cbCurInstr, pThis->cbCurInstr, pThis->abCurInstr, pThis->fInvalidEncoding));
5971
5972 /*
5973 * Do the rings.
5974 */
5975 for (iRing = pThis->iFirstRing + pThis->fSameRingNotOkay; iRing < pThis->iEndRing; iRing++)
5976 {
5977 PCBS3CG1TESTHDR pHdr;
5978
5979 pThis->uCpl = iRing;
5980 BS3CG1_DPRINTF(("dbg: Ring %u\n", iRing));
5981
5982 /*
5983 * Do the tests one by one.
5984 */
5985 pHdr = pThis->pTestHdr;
5986 for (pThis->iTest = 0;; pThis->iTest++)
5987 {
5988 if (Bs3Cg1RunSelector(pThis, pHdr))
5989 {
5990 /* Okay, set up the execution context. */
5991 unsigned offCode;
5992 uint8_t BS3_FAR *pbCode;
5993
5994 Bs3MemCpy(&pThis->Ctx, &pThis->aInitialCtxs[iRing], sizeof(pThis->Ctx));
5995 if (pThis->fWorkExtCtx)
5996 Bs3ExtCtxCopy(pThis->pExtCtx, pThis->pInitialExtCtx);
5997 if (BS3_MODE_IS_PAGED(pThis->bMode))
5998 {
5999 offCode = X86_PAGE_SIZE - pThis->cbCurInstr;
6000 pbCode = &pThis->pbCodePg[offCode];
6001 //if (iEncoding > 0) { pbCode[-1] = 0xf4; offCode--; }
6002 }
6003 else
6004 {
6005 pbCode = pThis->pbCodePg;
6006 pbCode[pThis->cbCurInstr] = 0x0f; /* UD2 */
6007 pbCode[pThis->cbCurInstr + 1] = 0x0b;
6008 offCode = 0;
6009 }
6010 pThis->Ctx.rip.u = pThis->CodePgRip + offCode;
6011 Bs3MemCpy(pbCode, pThis->abCurInstr, pThis->cbCurInstr);
6012
6013 if (Bs3Cg1RunContextModifier(pThis, &pThis->Ctx, pHdr, pHdr->cbSelector, pHdr->cbInput, NULL, pbCode))
6014 {
6015 /* Run the instruction. */
6016 BS3CG1_DPRINTF(("dbg: Running test #%u\n", pThis->iTest));
6017 //Bs3RegCtxPrint(&pThis->Ctx);
6018 if (pThis->fWorkExtCtx)
6019 Bs3ExtCtxRestore(pThis->pExtCtx);
6020 Bs3TrapSetJmpAndRestore(&pThis->Ctx, &pThis->TrapFrame);
6021 if (pThis->fWorkExtCtx)
6022 Bs3ExtCtxSave(pThis->pResultExtCtx);
6023 BS3CG1_DPRINTF(("dbg: bXcpt=%#x rip=%RX64 -> %RX64\n",
6024 pThis->TrapFrame.bXcpt, pThis->Ctx.rip.u, pThis->TrapFrame.Ctx.rip.u));
6025
6026 /*
6027 * Apply the output modification program to the context.
6028 */
6029 pThis->Ctx.rflags.u32 &= ~X86_EFL_RF;
6030 pThis->Ctx.rflags.u32 |= pThis->TrapFrame.Ctx.rflags.u32 & X86_EFL_RF;
6031 pThis->bValueXcpt = UINT8_MAX; //???
6032 if ( pThis->fInvalidEncoding
6033 || pThis->bAlignmentXcpt != UINT8_MAX
6034 || pThis->bValueXcpt != UINT8_MAX
6035 || Bs3Cg1RunContextModifier(pThis, &pThis->Ctx, pHdr,
6036 pHdr->cbSelector + pHdr->cbInput, pHdr->cbOutput,
6037 &pThis->TrapFrame.Ctx, NULL /*pbCode*/))
6038 Bs3Cg1CheckResult(pThis, bTestXcptExpected, false /*fInvalidEncodingPgFault*/, iEncoding);
6039 else
6040 {
6041 Bs3TestPrintf("Bs3Cg1RunContextModifier(out): iEncoding=%u iTest=%RU32 iInstr=%u %.*s\n",
6042 iEncoding, pThis->iTest, pThis->iInstr, pThis->cchMnemonic, pThis->pchMnemonic);
6043 ASMHalt();
6044 }
6045
6046 /*
6047 * If this is an invalid encoding or instruction, check that we
6048 * get a page fault when shortening it by one byte.
6049 * (Since we didn't execute the output context modifier, we don't
6050 * need to re-initialize the start context.)
6051 */
6052 if ( pThis->fInvalidEncoding
6053 && BS3_MODE_IS_PAGED(pThis->bMode)
6054 && pThis->cbCurInstr)
6055 {
6056 pbCode += 1;
6057 offCode += 1;
6058 pThis->Ctx.rip.u = pThis->CodePgRip + offCode;
6059 Bs3MemCpy(pbCode, pThis->abCurInstr, pThis->cbCurInstr - 1);
6060
6061 /* Run the instruction. */
6062 BS3CG1_DPRINTF(("dbg: Running test #%u (cut short #PF)\n", pThis->iTest));
6063 //Bs3RegCtxPrint(&pThis->Ctx);
6064 if (pThis->fWorkExtCtx)
6065 Bs3ExtCtxRestore(pThis->pExtCtx);
6066 Bs3TrapSetJmpAndRestore(&pThis->Ctx, &pThis->TrapFrame);
6067 if (pThis->fWorkExtCtx)
6068 Bs3ExtCtxSave(pThis->pResultExtCtx);
6069 BS3CG1_DPRINTF(("dbg: bXcpt=%#x rip=%RX64 -> %RX64 (cut short #PF)\n",
6070 pThis->TrapFrame.bXcpt, pThis->Ctx.rip.u, pThis->TrapFrame.Ctx.rip.u));
6071
6072 /* Check it */
6073 pThis->Ctx.rflags.u32 &= ~X86_EFL_RF;
6074 pThis->Ctx.rflags.u32 |= pThis->TrapFrame.Ctx.rflags.u32 & X86_EFL_RF;
6075 Bs3Cg1CheckResult(pThis, X86_XCPT_PF, true /*fInvalidEncodingPgFault*/, iEncoding);
6076 }
6077 }
6078 else
6079 {
6080 Bs3TestPrintf("Bs3Cg1RunContextModifier(in): iEncoding=%u iTest=%u iInstr=%RU32 %.*s\n",
6081 iEncoding, pThis->iTest, pThis->iInstr, pThis->cchMnemonic, pThis->pchMnemonic);
6082 ASMHalt();
6083 }
6084 }
6085 else
6086 BS3CG1_DPRINTF(("dbg: Skipping #%u\n", pThis->iTest));
6087
6088 /* advance */
6089 if (pHdr->fLast)
6090 {
6091 BS3CG1_DPRINTF(("dbg: Last\n\n"));
6092 break;
6093 }
6094 pHdr = (PCBS3CG1TESTHDR)((uint8_t BS3_FAR *)(pHdr + 1) + pHdr->cbInput + pHdr->cbOutput + pHdr->cbSelector);
6095 }
6096 }
6097 }
6098
6099 /*
6100 * Clean up (segment registers, etc) and get the next CPU config.
6101 */
6102 Bs3Cg1EncodeCleanup(pThis);
6103 if (!Bs3Cg1CpuSetupNext(pThis, iCpuSetup, &fOuterInvalidInstr))
6104 break;
6105 if (pThis->fFlags & (BS3CG1INSTR_F_UNUSED | BS3CG1INSTR_F_INVALID))
6106 fOuterInvalidInstr = true;
6107 }
6108 }
6109
6110 return 0;
6111}
6112
6113
6114BS3_DECL_FAR(uint8_t) BS3_CMN_NM(Bs3Cg1Worker)(uint8_t bMode)
6115{
6116 uint8_t bRet = 1;
6117 BS3CG1STATE This;
6118
6119#if 0
6120 /* (for debugging) */
6121 if (bMode != BS3_MODE_LM64)
6122 return BS3TESTDOMODE_SKIPPED;
6123#endif
6124
6125 if (BS3_CMN_NM(Bs3Cg1Init)(&This, bMode))
6126 {
6127 bRet = BS3_CMN_NM(Bs3Cg1WorkerInner)(&This);
6128 Bs3TestSubDone();
6129 }
6130 Bs3Cg1Destroy(&This);
6131
6132#if 0
6133 /* (for debugging) */
6134 if (bMode == BS3_MODE_PPV86)
6135 {
6136 Bs3TestTerm();
6137 Bs3Shutdown();
6138 }
6139#endif
6140 return bRet;
6141}
6142
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