IEMAllAImplC.cpp@ 63465

Last change on this file since 63465 was 63465, checked in by vboxsync, 8 years ago
VMM: warnings (clang)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 41.2 KB

Line
1	/* $Id: IEMAllAImplC.cpp 63465 2016-08-15 10:00:20Z vboxsync $ */
2	/** @file
3	* IEM - Instruction Implementation in Assembly, portable C variant.
4	*/
5
6	/*
7	* Copyright (C) 2011-2016 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
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include "IEMInternal.h"
23	#include <VBox/vmm/vm.h>
24	#include <iprt/x86.h>
25	#include <iprt/uint128.h>
26
27
28	/*********************************************************************************************************************************
29	* Global Variables *
30	*********************************************************************************************************************************/
31	#ifdef RT_ARCH_X86
32	/**
33	* Parity calculation table.
34	*
35	* The generator code:
36	* @code
37	* #include <stdio.h>
38	*
39	* int main()
40	* {
41	* unsigned b;
42	* for (b = 0; b < 256; b++)
43	* {
44	* int cOnes = ( b & 1)
45	* + ((b >> 1) & 1)
46	* + ((b >> 2) & 1)
47	* + ((b >> 3) & 1)
48	* + ((b >> 4) & 1)
49	* + ((b >> 5) & 1)
50	* + ((b >> 6) & 1)
51	* + ((b >> 7) & 1);
52	* printf(" /" "* %#04x = %u%u%u%u%u%u%u%ub *" "/ %s,\n",
53	* b,
54	* (b >> 7) & 1,
55	* (b >> 6) & 1,
56	* (b >> 5) & 1,
57	* (b >> 4) & 1,
58	* (b >> 3) & 1,
59	* (b >> 2) & 1,
60	* (b >> 1) & 1,
61	* b & 1,
62	* cOnes & 1 ? "0" : "X86_EFL_PF");
63	* }
64	* return 0;
65	* }
66	* @endcode
67	*/
68	static uint8_t const g_afParity[256] =
69	{
70	/* 0000 = 00000000b */ X86_EFL_PF,
71	/* 0x01 = 00000001b */ 0,
72	/* 0x02 = 00000010b */ 0,
73	/* 0x03 = 00000011b */ X86_EFL_PF,
74	/* 0x04 = 00000100b */ 0,
75	/* 0x05 = 00000101b */ X86_EFL_PF,
76	/* 0x06 = 00000110b */ X86_EFL_PF,
77	/* 0x07 = 00000111b */ 0,
78	/* 0x08 = 00001000b */ 0,
79	/* 0x09 = 00001001b */ X86_EFL_PF,
80	/* 0x0a = 00001010b */ X86_EFL_PF,
81	/* 0x0b = 00001011b */ 0,
82	/* 0x0c = 00001100b */ X86_EFL_PF,
83	/* 0x0d = 00001101b */ 0,
84	/* 0x0e = 00001110b */ 0,
85	/* 0x0f = 00001111b */ X86_EFL_PF,
86	/* 0x10 = 00010000b */ 0,
87	/* 0x11 = 00010001b */ X86_EFL_PF,
88	/* 0x12 = 00010010b */ X86_EFL_PF,
89	/* 0x13 = 00010011b */ 0,
90	/* 0x14 = 00010100b */ X86_EFL_PF,
91	/* 0x15 = 00010101b */ 0,
92	/* 0x16 = 00010110b */ 0,
93	/* 0x17 = 00010111b */ X86_EFL_PF,
94	/* 0x18 = 00011000b */ X86_EFL_PF,
95	/* 0x19 = 00011001b */ 0,
96	/* 0x1a = 00011010b */ 0,
97	/* 0x1b = 00011011b */ X86_EFL_PF,
98	/* 0x1c = 00011100b */ 0,
99	/* 0x1d = 00011101b */ X86_EFL_PF,
100	/* 0x1e = 00011110b */ X86_EFL_PF,
101	/* 0x1f = 00011111b */ 0,
102	/* 0x20 = 00100000b */ 0,
103	/* 0x21 = 00100001b */ X86_EFL_PF,
104	/* 0x22 = 00100010b */ X86_EFL_PF,
105	/* 0x23 = 00100011b */ 0,
106	/* 0x24 = 00100100b */ X86_EFL_PF,
107	/* 0x25 = 00100101b */ 0,
108	/* 0x26 = 00100110b */ 0,
109	/* 0x27 = 00100111b */ X86_EFL_PF,
110	/* 0x28 = 00101000b */ X86_EFL_PF,
111	/* 0x29 = 00101001b */ 0,
112	/* 0x2a = 00101010b */ 0,
113	/* 0x2b = 00101011b */ X86_EFL_PF,
114	/* 0x2c = 00101100b */ 0,
115	/* 0x2d = 00101101b */ X86_EFL_PF,
116	/* 0x2e = 00101110b */ X86_EFL_PF,
117	/* 0x2f = 00101111b */ 0,
118	/* 0x30 = 00110000b */ X86_EFL_PF,
119	/* 0x31 = 00110001b */ 0,
120	/* 0x32 = 00110010b */ 0,
121	/* 0x33 = 00110011b */ X86_EFL_PF,
122	/* 0x34 = 00110100b */ 0,
123	/* 0x35 = 00110101b */ X86_EFL_PF,
124	/* 0x36 = 00110110b */ X86_EFL_PF,
125	/* 0x37 = 00110111b */ 0,
126	/* 0x38 = 00111000b */ 0,
127	/* 0x39 = 00111001b */ X86_EFL_PF,
128	/* 0x3a = 00111010b */ X86_EFL_PF,
129	/* 0x3b = 00111011b */ 0,
130	/* 0x3c = 00111100b */ X86_EFL_PF,
131	/* 0x3d = 00111101b */ 0,
132	/* 0x3e = 00111110b */ 0,
133	/* 0x3f = 00111111b */ X86_EFL_PF,
134	/* 0x40 = 01000000b */ 0,
135	/* 0x41 = 01000001b */ X86_EFL_PF,
136	/* 0x42 = 01000010b */ X86_EFL_PF,
137	/* 0x43 = 01000011b */ 0,
138	/* 0x44 = 01000100b */ X86_EFL_PF,
139	/* 0x45 = 01000101b */ 0,
140	/* 0x46 = 01000110b */ 0,
141	/* 0x47 = 01000111b */ X86_EFL_PF,
142	/* 0x48 = 01001000b */ X86_EFL_PF,
143	/* 0x49 = 01001001b */ 0,
144	/* 0x4a = 01001010b */ 0,
145	/* 0x4b = 01001011b */ X86_EFL_PF,
146	/* 0x4c = 01001100b */ 0,
147	/* 0x4d = 01001101b */ X86_EFL_PF,
148	/* 0x4e = 01001110b */ X86_EFL_PF,
149	/* 0x4f = 01001111b */ 0,
150	/* 0x50 = 01010000b */ X86_EFL_PF,
151	/* 0x51 = 01010001b */ 0,
152	/* 0x52 = 01010010b */ 0,
153	/* 0x53 = 01010011b */ X86_EFL_PF,
154	/* 0x54 = 01010100b */ 0,
155	/* 0x55 = 01010101b */ X86_EFL_PF,
156	/* 0x56 = 01010110b */ X86_EFL_PF,
157	/* 0x57 = 01010111b */ 0,
158	/* 0x58 = 01011000b */ 0,
159	/* 0x59 = 01011001b */ X86_EFL_PF,
160	/* 0x5a = 01011010b */ X86_EFL_PF,
161	/* 0x5b = 01011011b */ 0,
162	/* 0x5c = 01011100b */ X86_EFL_PF,
163	/* 0x5d = 01011101b */ 0,
164	/* 0x5e = 01011110b */ 0,
165	/* 0x5f = 01011111b */ X86_EFL_PF,
166	/* 0x60 = 01100000b */ X86_EFL_PF,
167	/* 0x61 = 01100001b */ 0,
168	/* 0x62 = 01100010b */ 0,
169	/* 0x63 = 01100011b */ X86_EFL_PF,
170	/* 0x64 = 01100100b */ 0,
171	/* 0x65 = 01100101b */ X86_EFL_PF,
172	/* 0x66 = 01100110b */ X86_EFL_PF,
173	/* 0x67 = 01100111b */ 0,
174	/* 0x68 = 01101000b */ 0,
175	/* 0x69 = 01101001b */ X86_EFL_PF,
176	/* 0x6a = 01101010b */ X86_EFL_PF,
177	/* 0x6b = 01101011b */ 0,
178	/* 0x6c = 01101100b */ X86_EFL_PF,
179	/* 0x6d = 01101101b */ 0,
180	/* 0x6e = 01101110b */ 0,
181	/* 0x6f = 01101111b */ X86_EFL_PF,
182	/* 0x70 = 01110000b */ 0,
183	/* 0x71 = 01110001b */ X86_EFL_PF,
184	/* 0x72 = 01110010b */ X86_EFL_PF,
185	/* 0x73 = 01110011b */ 0,
186	/* 0x74 = 01110100b */ X86_EFL_PF,
187	/* 0x75 = 01110101b */ 0,
188	/* 0x76 = 01110110b */ 0,
189	/* 0x77 = 01110111b */ X86_EFL_PF,
190	/* 0x78 = 01111000b */ X86_EFL_PF,
191	/* 0x79 = 01111001b */ 0,
192	/* 0x7a = 01111010b */ 0,
193	/* 0x7b = 01111011b */ X86_EFL_PF,
194	/* 0x7c = 01111100b */ 0,
195	/* 0x7d = 01111101b */ X86_EFL_PF,
196	/* 0x7e = 01111110b */ X86_EFL_PF,
197	/* 0x7f = 01111111b */ 0,
198	/* 0x80 = 10000000b */ 0,
199	/* 0x81 = 10000001b */ X86_EFL_PF,
200	/* 0x82 = 10000010b */ X86_EFL_PF,
201	/* 0x83 = 10000011b */ 0,
202	/* 0x84 = 10000100b */ X86_EFL_PF,
203	/* 0x85 = 10000101b */ 0,
204	/* 0x86 = 10000110b */ 0,
205	/* 0x87 = 10000111b */ X86_EFL_PF,
206	/* 0x88 = 10001000b */ X86_EFL_PF,
207	/* 0x89 = 10001001b */ 0,
208	/* 0x8a = 10001010b */ 0,
209	/* 0x8b = 10001011b */ X86_EFL_PF,
210	/* 0x8c = 10001100b */ 0,
211	/* 0x8d = 10001101b */ X86_EFL_PF,
212	/* 0x8e = 10001110b */ X86_EFL_PF,
213	/* 0x8f = 10001111b */ 0,
214	/* 0x90 = 10010000b */ X86_EFL_PF,
215	/* 0x91 = 10010001b */ 0,
216	/* 0x92 = 10010010b */ 0,
217	/* 0x93 = 10010011b */ X86_EFL_PF,
218	/* 0x94 = 10010100b */ 0,
219	/* 0x95 = 10010101b */ X86_EFL_PF,
220	/* 0x96 = 10010110b */ X86_EFL_PF,
221	/* 0x97 = 10010111b */ 0,
222	/* 0x98 = 10011000b */ 0,
223	/* 0x99 = 10011001b */ X86_EFL_PF,
224	/* 0x9a = 10011010b */ X86_EFL_PF,
225	/* 0x9b = 10011011b */ 0,
226	/* 0x9c = 10011100b */ X86_EFL_PF,
227	/* 0x9d = 10011101b */ 0,
228	/* 0x9e = 10011110b */ 0,
229	/* 0x9f = 10011111b */ X86_EFL_PF,
230	/* 0xa0 = 10100000b */ X86_EFL_PF,
231	/* 0xa1 = 10100001b */ 0,
232	/* 0xa2 = 10100010b */ 0,
233	/* 0xa3 = 10100011b */ X86_EFL_PF,
234	/* 0xa4 = 10100100b */ 0,
235	/* 0xa5 = 10100101b */ X86_EFL_PF,
236	/* 0xa6 = 10100110b */ X86_EFL_PF,
237	/* 0xa7 = 10100111b */ 0,
238	/* 0xa8 = 10101000b */ 0,
239	/* 0xa9 = 10101001b */ X86_EFL_PF,
240	/* 0xaa = 10101010b */ X86_EFL_PF,
241	/* 0xab = 10101011b */ 0,
242	/* 0xac = 10101100b */ X86_EFL_PF,
243	/* 0xad = 10101101b */ 0,
244	/* 0xae = 10101110b */ 0,
245	/* 0xaf = 10101111b */ X86_EFL_PF,
246	/* 0xb0 = 10110000b */ 0,
247	/* 0xb1 = 10110001b */ X86_EFL_PF,
248	/* 0xb2 = 10110010b */ X86_EFL_PF,
249	/* 0xb3 = 10110011b */ 0,
250	/* 0xb4 = 10110100b */ X86_EFL_PF,
251	/* 0xb5 = 10110101b */ 0,
252	/* 0xb6 = 10110110b */ 0,
253	/* 0xb7 = 10110111b */ X86_EFL_PF,
254	/* 0xb8 = 10111000b */ X86_EFL_PF,
255	/* 0xb9 = 10111001b */ 0,
256	/* 0xba = 10111010b */ 0,
257	/* 0xbb = 10111011b */ X86_EFL_PF,
258	/* 0xbc = 10111100b */ 0,
259	/* 0xbd = 10111101b */ X86_EFL_PF,
260	/* 0xbe = 10111110b */ X86_EFL_PF,
261	/* 0xbf = 10111111b */ 0,
262	/* 0xc0 = 11000000b */ X86_EFL_PF,
263	/* 0xc1 = 11000001b */ 0,
264	/* 0xc2 = 11000010b */ 0,
265	/* 0xc3 = 11000011b */ X86_EFL_PF,
266	/* 0xc4 = 11000100b */ 0,
267	/* 0xc5 = 11000101b */ X86_EFL_PF,
268	/* 0xc6 = 11000110b */ X86_EFL_PF,
269	/* 0xc7 = 11000111b */ 0,
270	/* 0xc8 = 11001000b */ 0,
271	/* 0xc9 = 11001001b */ X86_EFL_PF,
272	/* 0xca = 11001010b */ X86_EFL_PF,
273	/* 0xcb = 11001011b */ 0,
274	/* 0xcc = 11001100b */ X86_EFL_PF,
275	/* 0xcd = 11001101b */ 0,
276	/* 0xce = 11001110b */ 0,
277	/* 0xcf = 11001111b */ X86_EFL_PF,
278	/* 0xd0 = 11010000b */ 0,
279	/* 0xd1 = 11010001b */ X86_EFL_PF,
280	/* 0xd2 = 11010010b */ X86_EFL_PF,
281	/* 0xd3 = 11010011b */ 0,
282	/* 0xd4 = 11010100b */ X86_EFL_PF,
283	/* 0xd5 = 11010101b */ 0,
284	/* 0xd6 = 11010110b */ 0,
285	/* 0xd7 = 11010111b */ X86_EFL_PF,
286	/* 0xd8 = 11011000b */ X86_EFL_PF,
287	/* 0xd9 = 11011001b */ 0,
288	/* 0xda = 11011010b */ 0,
289	/* 0xdb = 11011011b */ X86_EFL_PF,
290	/* 0xdc = 11011100b */ 0,
291	/* 0xdd = 11011101b */ X86_EFL_PF,
292	/* 0xde = 11011110b */ X86_EFL_PF,
293	/* 0xdf = 11011111b */ 0,
294	/* 0xe0 = 11100000b */ 0,
295	/* 0xe1 = 11100001b */ X86_EFL_PF,
296	/* 0xe2 = 11100010b */ X86_EFL_PF,
297	/* 0xe3 = 11100011b */ 0,
298	/* 0xe4 = 11100100b */ X86_EFL_PF,
299	/* 0xe5 = 11100101b */ 0,
300	/* 0xe6 = 11100110b */ 0,
301	/* 0xe7 = 11100111b */ X86_EFL_PF,
302	/* 0xe8 = 11101000b */ X86_EFL_PF,
303	/* 0xe9 = 11101001b */ 0,
304	/* 0xea = 11101010b */ 0,
305	/* 0xeb = 11101011b */ X86_EFL_PF,
306	/* 0xec = 11101100b */ 0,
307	/* 0xed = 11101101b */ X86_EFL_PF,
308	/* 0xee = 11101110b */ X86_EFL_PF,
309	/* 0xef = 11101111b */ 0,
310	/* 0xf0 = 11110000b */ X86_EFL_PF,
311	/* 0xf1 = 11110001b */ 0,
312	/* 0xf2 = 11110010b */ 0,
313	/* 0xf3 = 11110011b */ X86_EFL_PF,
314	/* 0xf4 = 11110100b */ 0,
315	/* 0xf5 = 11110101b */ X86_EFL_PF,
316	/* 0xf6 = 11110110b */ X86_EFL_PF,
317	/* 0xf7 = 11110111b */ 0,
318	/* 0xf8 = 11111000b */ 0,
319	/* 0xf9 = 11111001b */ X86_EFL_PF,
320	/* 0xfa = 11111010b */ X86_EFL_PF,
321	/* 0xfb = 11111011b */ 0,
322	/* 0xfc = 11111100b */ X86_EFL_PF,
323	/* 0xfd = 11111101b */ 0,
324	/* 0xfe = 11111110b */ 0,
325	/* 0xff = 11111111b */ X86_EFL_PF,
326	};
327	#endif /* RT_ARCH_X86 */
328
329
330	/**
331	* Calculates the signed flag value given a result and it's bit width.
332	*
333	* The signed flag (SF) is a duplication of the most significant bit in the
334	* result.
335	*
336	* @returns X86_EFL_SF or 0.
337	* @param a_uResult Unsigned result value.
338	* @param a_cBitsWidth The width of the result (8, 16, 32, 64).
339	*/
340	#define X86_EFL_CALC_SF(a_uResult, a_cBitsWidth) \
341	( (uint32_t)((a_uResult) >> ((a_cBitsWidth) - X86_EFL_SF_BIT)) & X86_EFL_SF )
342
343	/**
344	* Calculates the zero flag value given a result.
345	*
346	* The zero flag (ZF) indicates whether the result is zero or not.
347	*
348	* @returns X86_EFL_ZF or 0.
349	* @param a_uResult Unsigned result value.
350	*/
351	#define X86_EFL_CALC_ZF(a_uResult) \
352	( (uint32_t)((a_uResult) == 0) << X86_EFL_ZF_BIT )
353
354	/**
355	* Updates the status bits (CF, PF, AF, ZF, SF, and OF) after a logical op.
356	*
357	* CF and OF are defined to be 0 by logical operations. AF on the other hand is
358	* undefined. We do not set AF, as that seems to make the most sense (which
359	* probably makes it the most wrong in real life).
360	*
361	* @returns Status bits.
362	* @param a_pfEFlags Pointer to the 32-bit EFLAGS value to update.
363	* @param a_uResult Unsigned result value.
364	* @param a_cBitsWidth The width of the result (8, 16, 32, 64).
365	* @param a_fExtra Additional bits to set.
366	*/
367	#define IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(a_pfEFlags, a_uResult, a_cBitsWidth, a_fExtra) \
368	do { \
369	uint32_t fEflTmp = *(a_pfEFlags); \
370	fEflTmp &= ~X86_EFL_STATUS_BITS; \
371	fEflTmp \|= g_afParity[(a_uResult) & 0xff]; \
372	fEflTmp \|= X86_EFL_CALC_ZF(a_uResult); \
373	fEflTmp \|= X86_EFL_CALC_SF(a_uResult, a_cBitsWidth); \
374	fEflTmp \|= (a_fExtra); \
375	*(a_pfEFlags) = fEflTmp; \
376	} while (0)
377
378
379	#ifdef RT_ARCH_X86
380	/*
381	* There are a few 64-bit on 32-bit things we'd rather do in C. Actually, doing
382	* it all in C is probably safer atm., optimize what's necessary later, maybe.
383	*/
384
385
386	/* Binary ops */
387
388	IEM_DECL_IMPL_DEF(void, iemAImpl_add_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
389	{
390	uint64_t uDst = *puDst;
391	uint64_t uResult = uDst + uSrc;
392	*puDst = uResult;
393
394	/* Calc EFLAGS. */
395	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
396	fEfl \|= (uResult < uDst) << X86_EFL_CF_BIT;
397	fEfl \|= g_afParity[uResult & 0xff];
398	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uSrc ^ (uint32_t)uDst) & X86_EFL_AF;
399	fEfl \|= X86_EFL_CALC_ZF(uResult);
400	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
401	fEfl \|= (((uDst ^ uSrc ^ RT_BIT_64(63)) & (uResult ^ uDst)) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
402	*pfEFlags = fEfl;
403	}
404
405
406	IEM_DECL_IMPL_DEF(void, iemAImpl_adc_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
407	{
408	if (!(*pfEFlags & X86_EFL_CF))
409	iemAImpl_add_u64(puDst, uSrc, pfEFlags);
410	else
411	{
412	uint64_t uDst = *puDst;
413	uint64_t uResult = uDst + uSrc + 1;
414	*puDst = uResult;
415
416	/* Calc EFLAGS. */
417	/** @todo verify AF and OF calculations. */
418	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
419	fEfl \|= (uResult <= uDst) << X86_EFL_CF_BIT;
420	fEfl \|= g_afParity[uResult & 0xff];
421	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uSrc ^ (uint32_t)uDst) & X86_EFL_AF;
422	fEfl \|= X86_EFL_CALC_ZF(uResult);
423	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
424	fEfl \|= (((uDst ^ uSrc ^ RT_BIT_64(63)) & (uResult ^ uDst)) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
425	*pfEFlags = fEfl;
426	}
427	}
428
429
430	IEM_DECL_IMPL_DEF(void, iemAImpl_sub_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
431	{
432	uint64_t uDst = *puDst;
433	uint64_t uResult = uDst - uSrc;
434	*puDst = uResult;
435
436	/* Calc EFLAGS. */
437	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
438	fEfl \|= (uDst < uSrc) << X86_EFL_CF_BIT;
439	fEfl \|= g_afParity[uResult & 0xff];
440	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uSrc ^ (uint32_t)uDst) & X86_EFL_AF;
441	fEfl \|= X86_EFL_CALC_ZF(uResult);
442	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
443	fEfl \|= (((uDst ^ uSrc) & (uResult ^ uDst)) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
444	*pfEFlags = fEfl;
445	}
446
447
448	IEM_DECL_IMPL_DEF(void, iemAImpl_sbb_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
449	{
450	if (!(*pfEFlags & X86_EFL_CF))
451	iemAImpl_sub_u64(puDst, uSrc, pfEFlags);
452	else
453	{
454	uint64_t uDst = *puDst;
455	uint64_t uResult = uDst - uSrc - 1;
456	*puDst = uResult;
457
458	/* Calc EFLAGS. */
459	/** @todo verify AF and OF calculations. */
460	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
461	fEfl \|= (uDst <= uSrc) << X86_EFL_CF_BIT;
462	fEfl \|= g_afParity[uResult & 0xff];
463	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uSrc ^ (uint32_t)uDst) & X86_EFL_AF;
464	fEfl \|= X86_EFL_CALC_ZF(uResult);
465	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
466	fEfl \|= (((uDst ^ uSrc) & (uResult ^ uDst)) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
467	*pfEFlags = fEfl;
468	}
469	}
470
471
472	IEM_DECL_IMPL_DEF(void, iemAImpl_or_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
473	{
474	uint64_t uResult = *puDst \| uSrc;
475	*puDst = uResult;
476	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uResult, 64, 0);
477	}
478
479
480	IEM_DECL_IMPL_DEF(void, iemAImpl_xor_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
481	{
482	uint64_t uResult = *puDst ^ uSrc;
483	*puDst = uResult;
484	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uResult, 64, 0);
485	}
486
487
488	IEM_DECL_IMPL_DEF(void, iemAImpl_and_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
489	{
490	uint64_t uResult = *puDst & uSrc;
491	*puDst = uResult;
492	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uResult, 64, 0);
493	}
494
495
496	IEM_DECL_IMPL_DEF(void, iemAImpl_cmp_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
497	{
498	uint64_t uDstTmp = *puDst;
499	iemAImpl_sub_u64(&uDstTmp, uSrc, pfEFlags);
500	}
501
502
503	IEM_DECL_IMPL_DEF(void, iemAImpl_test_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
504	{
505	uint64_t uResult = *puDst & uSrc;
506	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uResult, 64, 0);
507	}
508
509
510	/** 64-bit locked binary operand operation. */
511	# define DO_LOCKED_BIN_OP_U64(a_Mnemonic) \
512	do { \
513	uint64_t uOld = ASMAtomicReadU64(puDst); \
514	uint64_t uTmp; \
515	uint32_t fEflTmp; \
516	do \
517	{ \
518	uTmp = uOld; \
519	fEflTmp = *pfEFlags; \
520	iemAImpl_ ## a_Mnemonic ## _u64(&uTmp, uSrc, &fEflTmp); \
521	} while (!ASMAtomicCmpXchgExU64(puDst, uTmp, uOld, &uOld)); \
522	*pfEFlags = fEflTmp; \
523	} while (0)
524
525
526	IEM_DECL_IMPL_DEF(void, iemAImpl_add_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
527	{
528	DO_LOCKED_BIN_OP_U64(adc);
529	}
530
531
532	IEM_DECL_IMPL_DEF(void, iemAImpl_adc_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
533	{
534	DO_LOCKED_BIN_OP_U64(adc);
535	}
536
537
538	IEM_DECL_IMPL_DEF(void, iemAImpl_sub_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
539	{
540	DO_LOCKED_BIN_OP_U64(sub);
541	}
542
543
544	IEM_DECL_IMPL_DEF(void, iemAImpl_sbb_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
545	{
546	DO_LOCKED_BIN_OP_U64(sbb);
547	}
548
549
550	IEM_DECL_IMPL_DEF(void, iemAImpl_or_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
551	{
552	DO_LOCKED_BIN_OP_U64(or);
553	}
554
555
556	IEM_DECL_IMPL_DEF(void, iemAImpl_xor_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
557	{
558	DO_LOCKED_BIN_OP_U64(xor);
559	}
560
561
562	IEM_DECL_IMPL_DEF(void, iemAImpl_and_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
563	{
564	DO_LOCKED_BIN_OP_U64(and);
565	}
566
567
568	IEM_DECL_IMPL_DEF(void, iemAImpl_xadd_u64,(uint64_t puDst, uint64_t puReg, uint32_t *pfEFlags))
569	{
570	uint64_t uDst = *puDst;
571	uint64_t uResult = uDst;
572	iemAImpl_add_u64(&uResult, *puReg, pfEFlags);
573	*puDst = uResult;
574	*puReg = uDst;
575	}
576
577
578	IEM_DECL_IMPL_DEF(void, iemAImpl_xadd_u64_locked,(uint64_t puDst, uint64_t puReg, uint32_t *pfEFlags))
579	{
580	uint64_t uOld = ASMAtomicReadU64(puDst);
581	uint64_t uTmpDst;
582	uint32_t fEflTmp;
583	do
584	{
585	uTmpDst = uOld;
586	fEflTmp = *pfEFlags;
587	iemAImpl_add_u64(&uTmpDst, *puReg, pfEFlags);
588	} while (!ASMAtomicCmpXchgExU64(puDst, uTmpDst, uOld, &uOld));
589	*puReg = uOld;
590	*pfEFlags = fEflTmp;
591	}
592
593
594	/* Bit operations (same signature as above). */
595
596	IEM_DECL_IMPL_DEF(void, iemAImpl_bt_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
597	{
598	/* Note! "undefined" flags: OF, SF, ZF, AF, PF. We set them as after an
599	logical operation (AND/OR/whatever). */
600	Assert(uSrc < 64);
601	uint64_t uDst = *puDst;
602	if (uDst & RT_BIT_64(uSrc))
603	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, X86_EFL_CF);
604	else
605	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, 0);
606	}
607
608	IEM_DECL_IMPL_DEF(void, iemAImpl_btc_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
609	{
610	/* Note! "undefined" flags: OF, SF, ZF, AF, PF. We set them as after an
611	logical operation (AND/OR/whatever). */
612	Assert(uSrc < 64);
613	uint64_t fMask = RT_BIT_64(uSrc);
614	uint64_t uDst = *puDst;
615	if (uDst & fMask)
616	{
617	uDst &= ~fMask;
618	*puDst = uDst;
619	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, X86_EFL_CF);
620	}
621	else
622	{
623	uDst \|= fMask;
624	*puDst = uDst;
625	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, 0);
626	}
627	}
628
629	IEM_DECL_IMPL_DEF(void, iemAImpl_btr_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
630	{
631	/* Note! "undefined" flags: OF, SF, ZF, AF, PF. We set them as after an
632	logical operation (AND/OR/whatever). */
633	Assert(uSrc < 64);
634	uint64_t fMask = RT_BIT_64(uSrc);
635	uint64_t uDst = *puDst;
636	if (uDst & fMask)
637	{
638	uDst &= ~fMask;
639	*puDst = uDst;
640	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, X86_EFL_CF);
641	}
642	else
643	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, 0);
644	}
645
646	IEM_DECL_IMPL_DEF(void, iemAImpl_bts_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
647	{
648	/* Note! "undefined" flags: OF, SF, ZF, AF, PF. We set them as after an
649	logical operation (AND/OR/whatever). */
650	Assert(uSrc < 64);
651	uint64_t fMask = RT_BIT_64(uSrc);
652	uint64_t uDst = *puDst;
653	if (uDst & fMask)
654	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, X86_EFL_CF);
655	else
656	{
657	uDst \|= fMask;
658	*puDst = uDst;
659	IEM_EFL_UPDATE_STATUS_BITS_FOR_LOGIC(pfEFlags, uDst, 64, 0);
660	}
661	}
662
663
664	IEM_DECL_IMPL_DEF(void, iemAImpl_btc_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
665	{
666	DO_LOCKED_BIN_OP_U64(btc);
667	}
668
669	IEM_DECL_IMPL_DEF(void, iemAImpl_btr_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
670	{
671	DO_LOCKED_BIN_OP_U64(btr);
672	}
673
674	IEM_DECL_IMPL_DEF(void, iemAImpl_bts_u64_locked,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
675	{
676	DO_LOCKED_BIN_OP_U64(bts);
677	}
678
679
680	/* bit scan */
681
682	IEM_DECL_IMPL_DEF(void, iemAImpl_bsf_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
683	{
684	/* Note! "undefined" flags: OF, SF, AF, PF, CF. */
685	/** @todo check what real CPUs does. */
686	if (uSrc)
687	{
688	uint8_t iBit;
689	uint32_t u32Src;
690	if (uSrc & UINT32_MAX)
691	{
692	iBit = 0;
693	u32Src = uSrc;
694	}
695	else
696	{
697	iBit = 32;
698	u32Src = uSrc >> 32;
699	}
700	if (!(u32Src & UINT16_MAX))
701	{
702	iBit += 16;
703	u32Src >>= 16;
704	}
705	if (!(u32Src & UINT8_MAX))
706	{
707	iBit += 8;
708	u32Src >>= 8;
709	}
710	if (!(u32Src & 0xf))
711	{
712	iBit += 4;
713	u32Src >>= 4;
714	}
715	if (!(u32Src & 0x3))
716	{
717	iBit += 2;
718	u32Src >>= 2;
719	}
720	if (!(u32Src & 1))
721	{
722	iBit += 1;
723	Assert(u32Src & 2);
724	}
725
726	*puDst = iBit;
727	*pfEFlags &= ~X86_EFL_ZF;
728	}
729	else
730	*pfEFlags \|= X86_EFL_ZF;
731	}
732
733	IEM_DECL_IMPL_DEF(void, iemAImpl_bsr_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
734	{
735	/* Note! "undefined" flags: OF, SF, AF, PF, CF. */
736	/** @todo check what real CPUs does. */
737	if (uSrc)
738	{
739	uint8_t iBit;
740	uint32_t u32Src;
741	if (uSrc & UINT64_C(0xffffffff00000000))
742	{
743	iBit = 64;
744	u32Src = uSrc >> 32;
745	}
746	else
747	{
748	iBit = 32;
749	u32Src = uSrc;
750	}
751	if (!(u32Src & UINT32_C(0xffff0000)))
752	{
753	iBit -= 16;
754	u32Src <<= 16;
755	}
756	if (!(u32Src & UINT32_C(0xff000000)))
757	{
758	iBit -= 8;
759	u32Src <<= 8;
760	}
761	if (!(u32Src & UINT32_C(0xf0000000)))
762	{
763	iBit -= 4;
764	u32Src <<= 4;
765	}
766	if (!(u32Src & UINT32_C(0xc0000000)))
767	{
768	iBit -= 2;
769	u32Src <<= 2;
770	}
771	if (!(u32Src & UINT32_C(0x10000000)))
772	{
773	iBit -= 1;
774	u32Src <<= 1;
775	Assert(u32Src & RT_BIT_64(63));
776	}
777
778	*puDst = iBit;
779	*pfEFlags &= ~X86_EFL_ZF;
780	}
781	else
782	*pfEFlags \|= X86_EFL_ZF;
783	}
784
785
786	/* Unary operands. */
787
788	IEM_DECL_IMPL_DEF(void, iemAImpl_inc_u64,(uint64_t puDst, uint32_t pfEFlags))
789	{
790	uint64_t uDst = *puDst;
791	uint64_t uResult = uDst + 1;
792	*puDst = uResult;
793
794	/*
795	* Calc EFLAGS.
796	* CF is NOT modified for hysterical raisins (allegedly for carrying and
797	* borrowing in arithmetic loops on intel 8008).
798	*/
799	uint32_t fEfl = *pfEFlags & ~(X86_EFL_STATUS_BITS & ~X86_EFL_CF);
800	fEfl \|= g_afParity[uResult & 0xff];
801	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uDst) & X86_EFL_AF;
802	fEfl \|= X86_EFL_CALC_ZF(uResult);
803	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
804	fEfl \|= (((uDst ^ RT_BIT_64(63)) & uResult) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
805	*pfEFlags = fEfl;
806	}
807
808
809	IEM_DECL_IMPL_DEF(void, iemAImpl_dec_u64,(uint64_t puDst, uint32_t pfEFlags))
810	{
811	uint64_t uDst = *puDst;
812	uint64_t uResult = uDst - 1;
813	*puDst = uResult;
814
815	/*
816	* Calc EFLAGS.
817	* CF is NOT modified for hysterical raisins (allegedly for carrying and
818	* borrowing in arithmetic loops on intel 8008).
819	*/
820	uint32_t fEfl = *pfEFlags & ~(X86_EFL_STATUS_BITS & ~X86_EFL_CF);
821	fEfl \|= g_afParity[uResult & 0xff];
822	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uDst) & X86_EFL_AF;
823	fEfl \|= X86_EFL_CALC_ZF(uResult);
824	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
825	fEfl \|= ((uDst & (uResult ^ RT_BIT_64(63))) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
826	*pfEFlags = fEfl;
827	}
828
829
830	IEM_DECL_IMPL_DEF(void, iemAImpl_not_u64,(uint64_t puDst, uint32_t pfEFlags))
831	{
832	uint64_t uDst = *puDst;
833	uint64_t uResult = ~uDst;
834	*puDst = uResult;
835	/* EFLAGS are not modified. */
836	RT_NOREF_PV(pfEFlags);
837	}
838
839
840	IEM_DECL_IMPL_DEF(void, iemAImpl_neg_u64,(uint64_t puDst, uint32_t pfEFlags))
841	{
842	uint64_t uDst = 0;
843	uint64_t uSrc = *puDst;
844	uint64_t uResult = uDst - uSrc;
845	*puDst = uResult;
846
847	/* Calc EFLAGS. */
848	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
849	fEfl \|= (uSrc != 0) << X86_EFL_CF_BIT;
850	fEfl \|= g_afParity[uResult & 0xff];
851	fEfl \|= ((uint32_t)uResult ^ (uint32_t)uDst) & X86_EFL_AF;
852	fEfl \|= X86_EFL_CALC_ZF(uResult);
853	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
854	fEfl \|= ((uSrc & uResult) >> (64 - X86_EFL_OF_BIT)) & X86_EFL_OF;
855	*pfEFlags = fEfl;
856	}
857
858
859	/** 64-bit locked unary operand operation. */
860	# define DO_LOCKED_UNARY_OP_U64(a_Mnemonic) \
861	do { \
862	uint64_t uOld = ASMAtomicReadU64(puDst); \
863	uint64_t uTmp; \
864	uint32_t fEflTmp; \
865	do \
866	{ \
867	uTmp = uOld; \
868	fEflTmp = *pfEFlags; \
869	iemAImpl_ ## a_Mnemonic ## _u64(&uTmp, &fEflTmp); \
870	} while (!ASMAtomicCmpXchgExU64(puDst, uTmp, uOld, &uOld)); \
871	*pfEFlags = fEflTmp; \
872	} while (0)
873
874	IEM_DECL_IMPL_DEF(void, iemAImpl_inc_u64_locked,(uint64_t puDst, uint32_t pfEFlags))
875	{
876	DO_LOCKED_UNARY_OP_U64(inc);
877	}
878
879
880	IEM_DECL_IMPL_DEF(void, iemAImpl_dec_u64_locked,(uint64_t puDst, uint32_t pfEFlags))
881	{
882	DO_LOCKED_UNARY_OP_U64(dec);
883	}
884
885
886	IEM_DECL_IMPL_DEF(void, iemAImpl_not_u64_locked,(uint64_t puDst, uint32_t pfEFlags))
887	{
888	DO_LOCKED_UNARY_OP_U64(not);
889	}
890
891
892	IEM_DECL_IMPL_DEF(void, iemAImpl_neg_u64_locked,(uint64_t puDst, uint32_t pfEFlags))
893	{
894	DO_LOCKED_UNARY_OP_U64(neg);
895	}
896
897
898	/* Shift and rotate. */
899
900	IEM_DECL_IMPL_DEF(void, iemAImpl_rol_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
901	{
902	cShift &= 63;
903	if (cShift)
904	{
905	uint64_t uDst = *puDst;
906	uint64_t uResult;
907	uResult = uDst << cShift;
908	uResult \|= uDst >> (64 - cShift);
909	*puDst = uResult;
910
911	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
912	it the same way as for 1 bit shifts. */
913	AssertCompile(X86_EFL_CF_BIT == 0);
914	uint32_t fEfl = *pfEFlags & ~(X86_EFL_CF \| X86_EFL_OF);
915	uint32_t fCarry = (uResult & 1);
916	fEfl \|= fCarry;
917	fEfl \|= ((uResult >> 63) ^ fCarry) << X86_EFL_OF_BIT;
918	*pfEFlags = fEfl;
919	}
920	}
921
922
923	IEM_DECL_IMPL_DEF(void, iemAImpl_ror_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
924	{
925	cShift &= 63;
926	if (cShift)
927	{
928	uint64_t uDst = *puDst;
929	uint64_t uResult;
930	uResult = uDst >> cShift;
931	uResult \|= uDst << (64 - cShift);
932	*puDst = uResult;
933
934	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
935	it the same way as for 1 bit shifts (OF = OF XOR New-CF). */
936	AssertCompile(X86_EFL_CF_BIT == 0);
937	uint32_t fEfl = *pfEFlags & ~(X86_EFL_CF \| X86_EFL_OF);
938	uint32_t fCarry = (uResult >> 63) & X86_EFL_CF;
939	fEfl \|= fCarry;
940	fEfl \|= (((uResult >> 62) ^ fCarry) << X86_EFL_OF_BIT) & X86_EFL_OF;
941	*pfEFlags = fEfl;
942	}
943	}
944
945
946	IEM_DECL_IMPL_DEF(void, iemAImpl_rcl_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
947	{
948	cShift &= 63;
949	if (cShift)
950	{
951	uint32_t fEfl = *pfEFlags;
952	uint64_t uDst = *puDst;
953	uint64_t uResult;
954	uResult = uDst << cShift;
955	AssertCompile(X86_EFL_CF_BIT == 0);
956	if (cShift > 1)
957	uResult \|= uDst >> (65 - cShift);
958	uResult \|= (uint64_t)(fEfl & X86_EFL_CF) << (cShift - 1);
959	*puDst = uResult;
960
961	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
962	it the same way as for 1 bit shifts. */
963	uint32_t fCarry = (uDst >> (64 - cShift)) & X86_EFL_CF;
964	fEfl &= ~(X86_EFL_CF \| X86_EFL_OF);
965	fEfl \|= fCarry;
966	fEfl \|= ((uResult >> 63) ^ fCarry) << X86_EFL_OF_BIT;
967	*pfEFlags = fEfl;
968	}
969	}
970
971
972	IEM_DECL_IMPL_DEF(void, iemAImpl_rcr_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
973	{
974	cShift &= 63;
975	if (cShift)
976	{
977	uint32_t fEfl = *pfEFlags;
978	uint64_t uDst = *puDst;
979	uint64_t uResult;
980	uResult = uDst >> cShift;
981	AssertCompile(X86_EFL_CF_BIT == 0);
982	if (cShift > 1)
983	uResult \|= uDst << (65 - cShift);
984	uResult \|= (uint64_t)(fEfl & X86_EFL_CF) << (64 - cShift);
985	*puDst = uResult;
986
987	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
988	it the same way as for 1 bit shifts. */
989	uint32_t fCarry = (uDst >> (cShift - 1)) & X86_EFL_CF;
990	fEfl &= ~(X86_EFL_CF \| X86_EFL_OF);
991	fEfl \|= fCarry;
992	fEfl \|= ((uResult >> 63) ^ fCarry) << X86_EFL_OF_BIT;
993	*pfEFlags = fEfl;
994	}
995	}
996
997
998	IEM_DECL_IMPL_DEF(void, iemAImpl_shl_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
999	{
1000	cShift &= 63;
1001	if (cShift)
1002	{
1003	uint64_t uDst = *puDst;
1004	uint64_t uResult = uDst << cShift;
1005	*puDst = uResult;
1006
1007	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
1008	it the same way as for 1 bit shifts. The AF bit is undefined, we
1009	always set it to zero atm. */
1010	AssertCompile(X86_EFL_CF_BIT == 0);
1011	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
1012	uint32_t fCarry = (uDst >> (64 - cShift)) & X86_EFL_CF;
1013	fEfl \|= fCarry;
1014	fEfl \|= ((uResult >> 63) ^ fCarry) << X86_EFL_OF_BIT;
1015	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
1016	fEfl \|= X86_EFL_CALC_ZF(uResult);
1017	fEfl \|= g_afParity[uResult & 0xff];
1018	*pfEFlags = fEfl;
1019	}
1020	}
1021
1022
1023	IEM_DECL_IMPL_DEF(void, iemAImpl_shr_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
1024	{
1025	cShift &= 63;
1026	if (cShift)
1027	{
1028	uint64_t uDst = *puDst;
1029	uint64_t uResult = uDst >> cShift;
1030	*puDst = uResult;
1031
1032	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
1033	it the same way as for 1 bit shifts. The AF bit is undefined, we
1034	always set it to zero atm. */
1035	AssertCompile(X86_EFL_CF_BIT == 0);
1036	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
1037	fEfl \|= (uDst >> (cShift - 1)) & X86_EFL_CF;
1038	fEfl \|= (uDst >> 63) << X86_EFL_OF_BIT;
1039	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
1040	fEfl \|= X86_EFL_CALC_ZF(uResult);
1041	fEfl \|= g_afParity[uResult & 0xff];
1042	*pfEFlags = fEfl;
1043	}
1044	}
1045
1046
1047	IEM_DECL_IMPL_DEF(void, iemAImpl_sar_u64,(uint64_t puDst, uint8_t cShift, uint32_t pfEFlags))
1048	{
1049	cShift &= 63;
1050	if (cShift)
1051	{
1052	uint64_t uDst = *puDst;
1053	uint64_t uResult = (int64_t)uDst >> cShift;
1054	*puDst = uResult;
1055
1056	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
1057	it the same way as for 1 bit shifts (0). The AF bit is undefined,
1058	we always set it to zero atm. */
1059	AssertCompile(X86_EFL_CF_BIT == 0);
1060	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
1061	fEfl \|= (uDst >> (cShift - 1)) & X86_EFL_CF;
1062	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
1063	fEfl \|= X86_EFL_CALC_ZF(uResult);
1064	fEfl \|= g_afParity[uResult & 0xff];
1065	*pfEFlags = fEfl;
1066	}
1067	}
1068
1069
1070	IEM_DECL_IMPL_DEF(void, iemAImpl_shld_u64,(uint64_t puDst, uint64_t uSrc, uint8_t cShift, uint32_t pfEFlags))
1071	{
1072	cShift &= 63;
1073	if (cShift)
1074	{
1075	uint64_t uDst = *puDst;
1076	uint64_t uResult;
1077	uResult = uDst << cShift;
1078	uResult \|= uSrc >> (64 - cShift);
1079	*puDst = uResult;
1080
1081	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
1082	it the same way as for 1 bit shifts. The AF bit is undefined,
1083	we always set it to zero atm. */
1084	AssertCompile(X86_EFL_CF_BIT == 0);
1085	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
1086	fEfl \|= (uDst >> (64 - cShift)) & X86_EFL_CF;
1087	fEfl \|= (uint32_t)((uDst >> 63) ^ (uint32_t)(uResult >> 63)) << X86_EFL_OF_BIT;
1088	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
1089	fEfl \|= X86_EFL_CALC_ZF(uResult);
1090	fEfl \|= g_afParity[uResult & 0xff];
1091	*pfEFlags = fEfl;
1092	}
1093	}
1094
1095
1096	IEM_DECL_IMPL_DEF(void, iemAImpl_shrd_u64,(uint64_t puDst, uint64_t uSrc, uint8_t cShift, uint32_t pfEFlags))
1097	{
1098	cShift &= 63;
1099	if (cShift)
1100	{
1101	uint64_t uDst = *puDst;
1102	uint64_t uResult;
1103	uResult = uDst >> cShift;
1104	uResult \|= uSrc << (64 - cShift);
1105	*puDst = uResult;
1106
1107	/* Calc EFLAGS. The OF bit is undefined if cShift > 1, we implement
1108	it the same way as for 1 bit shifts. The AF bit is undefined,
1109	we always set it to zero atm. */
1110	AssertCompile(X86_EFL_CF_BIT == 0);
1111	uint32_t fEfl = *pfEFlags & ~X86_EFL_STATUS_BITS;
1112	fEfl \|= (uDst >> (cShift - 1)) & X86_EFL_CF;
1113	fEfl \|= (uint32_t)((uDst >> 63) ^ (uint32_t)(uResult >> 63)) << X86_EFL_OF_BIT;
1114	fEfl \|= X86_EFL_CALC_SF(uResult, 64);
1115	fEfl \|= X86_EFL_CALC_ZF(uResult);
1116	fEfl \|= g_afParity[uResult & 0xff];
1117	*pfEFlags = fEfl;
1118	}
1119	}
1120
1121
1122	/* misc */
1123
1124	IEM_DECL_IMPL_DEF(void, iemAImpl_xchg_u64,(uint64_t puMem, uint64_t puReg))
1125	{
1126	/* XCHG implies LOCK. */
1127	uint64_t uOldMem = *puMem;
1128	while (!ASMAtomicCmpXchgExU64(puMem, *puReg, uOldMem, &uOldMem))
1129	ASMNopPause();
1130	*puReg = uOldMem;
1131	}
1132
1133
1134	#endif /* RT_ARCH_X86 */
1135	#ifdef RT_ARCH_X86
1136
1137	/* multiplication and division */
1138
1139
1140	IEM_DECL_IMPL_DEF(int, iemAImpl_mul_u64,(uint64_t pu64RAX, uint64_t pu64RDX, uint64_t u64Factor, uint32_t *pfEFlags))
1141	{
1142	RTUINT128U Result;
1143	RTUInt128MulU64ByU64(&Result, *pu64RAX, u64Factor);
1144	*pu64RAX = Result.s.Lo;
1145	*pu64RDX = Result.s.Hi;
1146
1147	/* MUL EFLAGS according to Skylake (similar to IMUL). */
1148	*pfEFlags &= ~(X86_EFL_SF \| X86_EFL_CF \| X86_EFL_OF \| X86_EFL_AF \| X86_EFL_ZF \| X86_EFL_PF);
1149	if (Result.s.Lo & RT_BIT_64(63))
1150	*pfEFlags \|= X86_EFL_SF;
1151	pfEFlags \|= g_afParity[Result.s.Lo & 0xff]; / (Skylake behaviour) */
1152	if (Result.s.Hi != 0)
1153	*pfEFlags \|= X86_EFL_CF \| X86_EFL_OF;
1154	return 0;
1155	}
1156
1157
1158	IEM_DECL_IMPL_DEF(int, iemAImpl_imul_u64,(uint64_t pu64RAX, uint64_t pu64RDX, uint64_t u64Factor, uint32_t *pfEFlags))
1159	{
1160	RTUINT128U Result;
1161	*pfEFlags &= ~( X86_EFL_SF \| X86_EFL_CF \| X86_EFL_OF
1162	/* Skylake always clears: */ \| X86_EFL_AF \| X86_EFL_ZF
1163	/* Skylake may set: */ \| X86_EFL_PF);
1164
1165	if ((int64_t)*pu64RAX >= 0)
1166	{
1167	if ((int64_t)u64Factor >= 0)
1168	{
1169	RTUInt128MulU64ByU64(&Result, *pu64RAX, u64Factor);
1170	if (Result.s.Hi != 0 \|\| Result.s.Lo >= UINT64_C(0x8000000000000000))
1171	*pfEFlags \|= X86_EFL_CF \| X86_EFL_OF;
1172	}
1173	else
1174	{
1175	RTUInt128MulU64ByU64(&Result, *pu64RAX, UINT64_C(0) - u64Factor);
1176	if (Result.s.Hi != 0 \|\| Result.s.Lo > UINT64_C(0x8000000000000000))
1177	*pfEFlags \|= X86_EFL_CF \| X86_EFL_OF;
1178	RTUInt128AssignNeg(&Result);
1179	}
1180	}
1181	else
1182	{
1183	if ((int64_t)u64Factor >= 0)
1184	{
1185	RTUInt128MulU64ByU64(&Result, UINT64_C(0) - *pu64RAX, u64Factor);
1186	if (Result.s.Hi != 0 \|\| Result.s.Lo > UINT64_C(0x8000000000000000))
1187	*pfEFlags \|= X86_EFL_CF \| X86_EFL_OF;
1188	RTUInt128AssignNeg(&Result);
1189	}
1190	else
1191	{
1192	RTUInt128MulU64ByU64(&Result, UINT64_C(0) - *pu64RAX, UINT64_C(0) - u64Factor);
1193	if (Result.s.Hi != 0 \|\| Result.s.Lo >= UINT64_C(0x8000000000000000))
1194	*pfEFlags \|= X86_EFL_CF \| X86_EFL_OF;
1195	}
1196	}
1197	*pu64RAX = Result.s.Lo;
1198	if (Result.s.Lo & RT_BIT_64(63))
1199	*pfEFlags \|= X86_EFL_SF;
1200	pfEFlags \|= g_afParity[Result.s.Lo & 0xff]; / (Skylake behaviour) */
1201	*pu64RDX = Result.s.Hi;
1202
1203	return 0;
1204	}
1205
1206
1207	IEM_DECL_IMPL_DEF(void, iemAImpl_imul_two_u64,(uint64_t puDst, uint64_t uSrc, uint32_t pfEFlags))
1208	{
1209	/** @todo Testcase: IMUL 2 and 3 operands. */
1210	uint64_t u64Ign;
1211	iemAImpl_imul_u64(puDst, &u64Ign, uSrc, pfEFlags);
1212	}
1213
1214
1215
1216	IEM_DECL_IMPL_DEF(int, iemAImpl_div_u64,(uint64_t pu64RAX, uint64_t pu64RDX, uint64_t u64Divisor, uint32_t *pfEFlags))
1217	{
1218	/* Note! Skylake leaves all flags alone. */
1219	RT_NOREF_PV(pfEFlags);
1220
1221	if ( u64Divisor != 0
1222	&& *pu64RDX < u64Divisor)
1223	{
1224	RTUINT128U Dividend;
1225	Dividend.s.Lo = *pu64RAX;
1226	Dividend.s.Hi = *pu64RDX;
1227
1228	RTUINT128U Divisor;
1229	Divisor.s.Lo = u64Divisor;
1230	Divisor.s.Hi = 0;
1231
1232	RTUINT128U Remainder;
1233	RTUINT128U Quotient;
1234	# ifdef __GNUC__ /* GCC maybe really annoying in function. */
1235	Quotient.s.Lo = 0;
1236	Quotient.s.Hi = 0;
1237	# endif
1238	RTUInt128DivRem(&Quotient, &Remainder, &Dividend, &Divisor);
1239	Assert(Quotient.s.Hi == 0);
1240	Assert(Remainder.s.Hi == 0);
1241
1242	*pu64RAX = Quotient.s.Lo;
1243	*pu64RDX = Remainder.s.Lo;
1244	/** @todo research the undefined DIV flags. */
1245	return 0;
1246
1247	}
1248	/* #DE */
1249	return VERR_IEM_ASPECT_NOT_IMPLEMENTED;
1250	}
1251
1252
1253	IEM_DECL_IMPL_DEF(int, iemAImpl_idiv_u64,(uint64_t pu64RAX, uint64_t pu64RDX, uint64_t u64Divisor, uint32_t *pfEFlags))
1254	{
1255	/* Note! Skylake leaves all flags alone. */
1256	RT_NOREF_PV(pfEFlags);
1257
1258	if (u64Divisor != 0)
1259	{
1260	/*
1261	* Convert to unsigned division.
1262	*/
1263	RTUINT128U Dividend;
1264	Dividend.s.Lo = *pu64RAX;
1265	Dividend.s.Hi = *pu64RDX;
1266	if ((int64_t)*pu64RDX < 0)
1267	RTUInt128AssignNeg(&Dividend);
1268
1269	RTUINT128U Divisor;
1270	Divisor.s.Hi = 0;
1271	if ((int64_t)u64Divisor >= 0)
1272	Divisor.s.Lo = u64Divisor;
1273	else
1274	Divisor.s.Lo = UINT64_C(0) - u64Divisor;
1275
1276	RTUINT128U Remainder;
1277	RTUINT128U Quotient;
1278	# ifdef __GNUC__ /* GCC maybe really annoying in function. */
1279	Quotient.s.Lo = 0;
1280	Quotient.s.Hi = 0;
1281	# endif
1282	RTUInt128DivRem(&Quotient, &Remainder, &Dividend, &Divisor);
1283
1284	/*
1285	* Setup the result, checking for overflows.
1286	*/
1287	if ((int64_t)u64Divisor >= 0)
1288	{
1289	if ((int64_t)*pu64RDX >= 0)
1290	{
1291	/* Positive divisor, positive dividend => result positive. */
1292	if (Quotient.s.Hi == 0 && Quotient.s.Lo <= (uint64_t)INT64_MAX)
1293	{
1294	*pu64RAX = Quotient.s.Lo;
1295	*pu64RDX = Remainder.s.Lo;
1296	return 0;
1297	}
1298	}
1299	else
1300	{
1301	/* Positive divisor, positive dividend => result negative. */
1302	if (Quotient.s.Hi == 0 && Quotient.s.Lo <= UINT64_C(0x8000000000000000))
1303	{
1304	*pu64RAX = UINT64_C(0) - Quotient.s.Lo;
1305	*pu64RDX = UINT64_C(0) - Remainder.s.Lo;
1306	return 0;
1307	}
1308	}
1309	}
1310	else
1311	{
1312	if ((int64_t)*pu64RDX >= 0)
1313	{
1314	/* Negative divisor, positive dividend => negative quotient, positive remainder. */
1315	if (Quotient.s.Hi == 0 && Quotient.s.Lo <= UINT64_C(0x8000000000000000))
1316	{
1317	*pu64RAX = UINT64_C(0) - Quotient.s.Lo;
1318	*pu64RDX = Remainder.s.Lo;
1319	return 0;
1320	}
1321	}
1322	else
1323	{
1324	/* Negative divisor, negative dividend => positive quotient, negative remainder. */
1325	if (Quotient.s.Hi == 0 && Quotient.s.Lo <= (uint64_t)INT64_MAX)
1326	{
1327	*pu64RAX = Quotient.s.Lo;
1328	*pu64RDX = UINT64_C(0) - Remainder.s.Lo;
1329	return 0;
1330	}
1331	}
1332	}
1333	}
1334	/* #DE */
1335	return VERR_IEM_ASPECT_NOT_IMPLEMENTED;
1336	}
1337
1338
1339	#endif /* RT_ARCH_X86 */
1340
1341
1342	IEM_DECL_IMPL_DEF(void, iemAImpl_arpl,(uint16_t pu16Dst, uint16_t u16Src, uint32_t pfEFlags))
1343	{
1344	if ((*pu16Dst & X86_SEL_RPL) < (u16Src & X86_SEL_RPL))
1345	{
1346	*pu16Dst &= X86_SEL_MASK_OFF_RPL;
1347	*pu16Dst \|= u16Src & X86_SEL_RPL;
1348
1349	*pfEFlags \|= X86_EFL_ZF;
1350	}
1351	else
1352	*pfEFlags &= ~X86_EFL_ZF;
1353	}
1354

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/VMM/VMMAll/IEMAllAImplC.cpp@ 63465

Download in other formats: