CPUMAllCpuId.cpp

Last change on this file was 109029, checked in by vboxsync, 3 weeks ago
SUP,VBoxCpuReport,VMM/CPUM: Deal with core variations on arm CPUs when generating reports for them. jiraref:VBP-1598
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 111.6 KB

Line
1	/* $Id: CPUMAllCpuId.cpp 109029 2025-04-20 02:48:56Z vboxsync $ */
2	/** @file
3	* CPUM - CPU ID part, common bits.
4	*/
5
6	/*
7	* Copyright (C) 2013-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.215389.xyz.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_CPUM
33	#include <VBox/vmm/cpum.h>
34	#include <VBox/vmm/hm.h>
35	#include <VBox/vmm/ssm.h>
36	#include "CPUMInternal.h"
37	#include <VBox/vmm/vmcc.h>
38	#include <VBox/sup.h>
39
40	#include <VBox/err.h>
41	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64)
42	# include <iprt/asm-amd64-x86.h>
43	#endif
44	#include <iprt/ctype.h>
45	#include <iprt/mem.h>
46	#include <iprt/string.h>
47	#include <iprt/x86-helpers.h>
48	#if defined(RT_ARCH_ARM64) \|\| defined(VBOX_VMM_TARGET_ARMV8)
49	# include <iprt/armv8.h>
50	# if defined(RT_OS_LINUX)
51	# include <sys/auxv.h>
52	# endif
53	#endif
54
55
56	/*********************************************************************************************************************************
57	* Global Variables *
58	*********************************************************************************************************************************/
59	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86)
60	/**
61	* The intel pentium family.
62	*/
63	static const CPUMMICROARCH g_aenmIntelFamily06[] =
64	{
65	/* [ 0(0x00)] = / kCpumMicroarch_Intel_P6, / Pentium Pro A-step (says sandpile.org). */
66	/* [ 1(0x01)] = / kCpumMicroarch_Intel_P6, / Pentium Pro */
67	/* [ 2(0x02)] = */ kCpumMicroarch_Intel_Unknown,
68	/* [ 3(0x03)] = / kCpumMicroarch_Intel_P6_II, / PII Klamath */
69	/* [ 4(0x04)] = */ kCpumMicroarch_Intel_Unknown,
70	/* [ 5(0x05)] = / kCpumMicroarch_Intel_P6_II, / PII Deschutes */
71	/* [ 6(0x06)] = / kCpumMicroarch_Intel_P6_II, / Celeron Mendocino. */
72	/* [ 7(0x07)] = / kCpumMicroarch_Intel_P6_III, / PIII Katmai. */
73	/* [ 8(0x08)] = / kCpumMicroarch_Intel_P6_III, / PIII Coppermine (includes Celeron). */
74	/* [ 9(0x09)] = / kCpumMicroarch_Intel_P6_M_Banias, / Pentium/Celeron M Banias. */
75	/* [10(0x0a)] = / kCpumMicroarch_Intel_P6_III, / PIII Xeon */
76	/* [11(0x0b)] = / kCpumMicroarch_Intel_P6_III, / PIII Tualatin (includes Celeron). */
77	/* [12(0x0c)] = */ kCpumMicroarch_Intel_Unknown,
78	/* [13(0x0d)] = / kCpumMicroarch_Intel_P6_M_Dothan, / Pentium/Celeron M Dothan. */
79	/* [14(0x0e)] = / kCpumMicroarch_Intel_Core_Yonah, / Core Yonah (Enhanced Pentium M). */
80	/* [15(0x0f)] = / kCpumMicroarch_Intel_Core2_Merom, / Merom */
81	/* [16(0x10)] = */ kCpumMicroarch_Intel_Unknown,
82	/* [17(0x11)] = */ kCpumMicroarch_Intel_Unknown,
83	/* [18(0x12)] = */ kCpumMicroarch_Intel_Unknown,
84	/* [19(0x13)] = */ kCpumMicroarch_Intel_Unknown,
85	/* [20(0x14)] = */ kCpumMicroarch_Intel_Unknown,
86	/* [21(0x15)] = / kCpumMicroarch_Intel_P6_M_Dothan, / Tolapai - System-on-a-chip. */
87	/* [22(0x16)] = */ kCpumMicroarch_Intel_Core2_Merom,
88	/* [23(0x17)] = */ kCpumMicroarch_Intel_Core2_Penryn,
89	/* [24(0x18)] = */ kCpumMicroarch_Intel_Unknown,
90	/* [25(0x19)] = */ kCpumMicroarch_Intel_Unknown,
91	/* [26(0x1a)] = / kCpumMicroarch_Intel_Core7_Nehalem, / Nehalem-EP */
92	/* [27(0x1b)] = */ kCpumMicroarch_Intel_Unknown,
93	/* [28(0x1c)] = / kCpumMicroarch_Intel_Atom_Bonnell, / Diamonville, Pineview, */
94	/* [29(0x1d)] = */ kCpumMicroarch_Intel_Core2_Penryn,
95	/* [30(0x1e)] = / kCpumMicroarch_Intel_Core7_Nehalem, / Clarksfield, Lynnfield, Jasper Forest. */
96	/* [31(0x1f)] = / kCpumMicroarch_Intel_Core7_Nehalem, / Only listed by sandpile.org. 2 cores ABD/HVD, whatever that means. */
97	/* [32(0x20)] = */ kCpumMicroarch_Intel_Unknown,
98	/* [33(0x21)] = */ kCpumMicroarch_Intel_Unknown,
99	/* [34(0x22)] = */ kCpumMicroarch_Intel_Unknown,
100	/* [35(0x23)] = */ kCpumMicroarch_Intel_Unknown,
101	/* [36(0x24)] = */ kCpumMicroarch_Intel_Unknown,
102	/* [37(0x25)] = / kCpumMicroarch_Intel_Core7_Westmere, / Arrandale, Clarksdale. */
103	/* [38(0x26)] = */ kCpumMicroarch_Intel_Atom_Lincroft,
104	/* [39(0x27)] = */ kCpumMicroarch_Intel_Atom_Saltwell,
105	/* [40(0x28)] = */ kCpumMicroarch_Intel_Unknown,
106	/* [41(0x29)] = */ kCpumMicroarch_Intel_Unknown,
107	/* [42(0x2a)] = */ kCpumMicroarch_Intel_Core7_SandyBridge,
108	/* [43(0x2b)] = */ kCpumMicroarch_Intel_Unknown,
109	/* [44(0x2c)] = / kCpumMicroarch_Intel_Core7_Westmere, / Gulftown, Westmere-EP. */
110	/* [45(0x2d)] = / kCpumMicroarch_Intel_Core7_SandyBridge, / SandyBridge-E, SandyBridge-EN, SandyBridge-EP. */
111	/* [46(0x2e)] = / kCpumMicroarch_Intel_Core7_Nehalem, / Beckton (Xeon). */
112	/* [47(0x2f)] = / kCpumMicroarch_Intel_Core7_Westmere, / Westmere-EX. */
113	/* [48(0x30)] = */ kCpumMicroarch_Intel_Unknown,
114	/* [49(0x31)] = */ kCpumMicroarch_Intel_Unknown,
115	/* [50(0x32)] = */ kCpumMicroarch_Intel_Unknown,
116	/* [51(0x33)] = */ kCpumMicroarch_Intel_Unknown,
117	/* [52(0x34)] = */ kCpumMicroarch_Intel_Unknown,
118	/* [53(0x35)] = / kCpumMicroarch_Intel_Atom_Saltwell, / ?? */
119	/* [54(0x36)] = / kCpumMicroarch_Intel_Atom_Saltwell, / Cedarview, ++ */
120	/* [55(0x37)] = */ kCpumMicroarch_Intel_Atom_Silvermont,
121	/* [56(0x38)] = */ kCpumMicroarch_Intel_Unknown,
122	/* [57(0x39)] = */ kCpumMicroarch_Intel_Unknown,
123	/* [58(0x3a)] = */ kCpumMicroarch_Intel_Core7_IvyBridge,
124	/* [59(0x3b)] = */ kCpumMicroarch_Intel_Unknown,
125	/* [60(0x3c)] = */ kCpumMicroarch_Intel_Core7_Haswell,
126	/* [61(0x3d)] = */ kCpumMicroarch_Intel_Core7_Broadwell,
127	/* [62(0x3e)] = */ kCpumMicroarch_Intel_Core7_IvyBridge,
128	/* [63(0x3f)] = */ kCpumMicroarch_Intel_Core7_Haswell,
129	/* [64(0x40)] = */ kCpumMicroarch_Intel_Unknown,
130	/* [65(0x41)] = */ kCpumMicroarch_Intel_Unknown,
131	/* [66(0x42)] = */ kCpumMicroarch_Intel_Unknown,
132	/* [67(0x43)] = */ kCpumMicroarch_Intel_Unknown,
133	/* [68(0x44)] = */ kCpumMicroarch_Intel_Unknown,
134	/* [69(0x45)] = */ kCpumMicroarch_Intel_Core7_Haswell,
135	/* [70(0x46)] = */ kCpumMicroarch_Intel_Core7_Haswell,
136	/* [71(0x47)] = / kCpumMicroarch_Intel_Core7_Broadwell, / i7-5775C */
137	/* [72(0x48)] = */ kCpumMicroarch_Intel_Unknown,
138	/* [73(0x49)] = */ kCpumMicroarch_Intel_Unknown,
139	/* [74(0x4a)] = */ kCpumMicroarch_Intel_Atom_Silvermont,
140	/* [75(0x4b)] = */ kCpumMicroarch_Intel_Unknown,
141	/* [76(0x4c)] = */ kCpumMicroarch_Intel_Atom_Airmount,
142	/* [77(0x4d)] = */ kCpumMicroarch_Intel_Atom_Silvermont,
143	/* [78(0x4e)] = */ kCpumMicroarch_Intel_Core7_Skylake,
144	/* [79(0x4f)] = / kCpumMicroarch_Intel_Core7_Broadwell, / Broadwell-E */
145	/* [80(0x50)] = */ kCpumMicroarch_Intel_Unknown,
146	/* [81(0x51)] = */ kCpumMicroarch_Intel_Unknown,
147	/* [82(0x52)] = */ kCpumMicroarch_Intel_Unknown,
148	/* [83(0x53)] = */ kCpumMicroarch_Intel_Unknown,
149	/* [84(0x54)] = */ kCpumMicroarch_Intel_Unknown,
150	/* [85(0x55)] = / kCpumMicroarch_Intel_Core7_Skylake, / server cpu; skylake <= 4, cascade lake > 5 */
151	/* [86(0x56)] = / kCpumMicroarch_Intel_Core7_Broadwell, / Xeon D-1540, Broadwell-DE */
152	/* [87(0x57)] = */ kCpumMicroarch_Intel_Phi_KnightsLanding,
153	/* [88(0x58)] = */ kCpumMicroarch_Intel_Unknown,
154	/* [89(0x59)] = */ kCpumMicroarch_Intel_Unknown,
155	/* [90(0x5a)] = / kCpumMicroarch_Intel_Atom_Silvermont, / Moorefield */
156	/* [91(0x5b)] = */ kCpumMicroarch_Intel_Unknown,
157	/* [92(0x5c)] = / kCpumMicroarch_Intel_Atom_Goldmont, / Apollo Lake */
158	/* [93(0x5d)] = / kCpumMicroarch_Intel_Atom_Silvermont, / x3-C3230 */
159	/* [94(0x5e)] = / kCpumMicroarch_Intel_Core7_Skylake, / i7-6700K */
160	/* [95(0x5f)] = / kCpumMicroarch_Intel_Atom_Goldmont, / Denverton */
161	/* [96(0x60)] = */ kCpumMicroarch_Intel_Unknown,
162	/* [97(0x61)] = */ kCpumMicroarch_Intel_Unknown,
163	/* [98(0x62)] = */ kCpumMicroarch_Intel_Unknown,
164	/* [99(0x63)] = */ kCpumMicroarch_Intel_Unknown,
165	/[100(0x64)] = / kCpumMicroarch_Intel_Unknown,
166	/[101(0x65)] = / kCpumMicroarch_Intel_Atom_Silvermont, /* SoFIA */
167	/[102(0x66)] = / kCpumMicroarch_Intel_Core7_CannonLake, /* unconfirmed */
168	/[103(0x67)] = / kCpumMicroarch_Intel_Unknown,
169	/[104(0x68)] = / kCpumMicroarch_Intel_Unknown,
170	/[105(0x69)] = / kCpumMicroarch_Intel_Unknown,
171	/[106(0x6a)] = / kCpumMicroarch_Intel_Core7_IceLake, /* unconfirmed server */
172	/[107(0x6b)] = / kCpumMicroarch_Intel_Unknown,
173	/[108(0x6c)] = / kCpumMicroarch_Intel_Core7_IceLake, /* unconfirmed server */
174	/[109(0x6d)] = / kCpumMicroarch_Intel_Unknown,
175	/[110(0x6e)] = / kCpumMicroarch_Intel_Atom_Airmount, /* or silvermount? */
176	/[111(0x6f)] = / kCpumMicroarch_Intel_Unknown,
177	/[112(0x70)] = / kCpumMicroarch_Intel_Unknown,
178	/[113(0x71)] = / kCpumMicroarch_Intel_Unknown,
179	/[114(0x72)] = / kCpumMicroarch_Intel_Unknown,
180	/[115(0x73)] = / kCpumMicroarch_Intel_Unknown,
181	/[116(0x74)] = / kCpumMicroarch_Intel_Unknown,
182	/[117(0x75)] = / kCpumMicroarch_Intel_Atom_Airmount, /* or silvermount? */
183	/[118(0x76)] = / kCpumMicroarch_Intel_Unknown,
184	/[119(0x77)] = / kCpumMicroarch_Intel_Unknown,
185	/[120(0x78)] = / kCpumMicroarch_Intel_Unknown,
186	/[121(0x79)] = / kCpumMicroarch_Intel_Unknown,
187	/[122(0x7a)] = / kCpumMicroarch_Intel_Atom_GoldmontPlus,
188	/[123(0x7b)] = / kCpumMicroarch_Intel_Unknown,
189	/[124(0x7c)] = / kCpumMicroarch_Intel_Unknown,
190	/[125(0x7d)] = / kCpumMicroarch_Intel_Core7_IceLake, /* unconfirmed */
191	/[126(0x7e)] = / kCpumMicroarch_Intel_Core7_IceLake, /* unconfirmed */
192	/[127(0x7f)] = / kCpumMicroarch_Intel_Unknown,
193	/[128(0x80)] = / kCpumMicroarch_Intel_Unknown,
194	/[129(0x81)] = / kCpumMicroarch_Intel_Unknown,
195	/[130(0x82)] = / kCpumMicroarch_Intel_Unknown,
196	/[131(0x83)] = / kCpumMicroarch_Intel_Unknown,
197	/[132(0x84)] = / kCpumMicroarch_Intel_Unknown,
198	/[133(0x85)] = / kCpumMicroarch_Intel_Phi_KnightsMill,
199	/[134(0x86)] = / kCpumMicroarch_Intel_Unknown,
200	/[135(0x87)] = / kCpumMicroarch_Intel_Unknown,
201	/[136(0x88)] = / kCpumMicroarch_Intel_Unknown,
202	/[137(0x89)] = / kCpumMicroarch_Intel_Unknown,
203	/[138(0x8a)] = / kCpumMicroarch_Intel_Unknown,
204	/[139(0x8b)] = / kCpumMicroarch_Intel_Unknown,
205	/[140(0x8c)] = / kCpumMicroarch_Intel_Core7_TigerLake, /* 11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz (bird) */
206	/[141(0x8d)] = / kCpumMicroarch_Intel_Core7_TigerLake, /* unconfirmed */
207	/[142(0x8e)] = / kCpumMicroarch_Intel_Core7_KabyLake, /* Stepping >= 0xB is Whiskey Lake, 0xA is CoffeeLake. */
208	/[143(0x8f)] = / kCpumMicroarch_Intel_Core7_SapphireRapids,
209	/[144(0x90)] = / kCpumMicroarch_Intel_Unknown,
210	/[145(0x91)] = / kCpumMicroarch_Intel_Unknown,
211	/[146(0x92)] = / kCpumMicroarch_Intel_Unknown,
212	/[147(0x93)] = / kCpumMicroarch_Intel_Unknown,
213	/[148(0x94)] = / kCpumMicroarch_Intel_Unknown,
214	/[149(0x95)] = / kCpumMicroarch_Intel_Unknown,
215	/[150(0x96)] = / kCpumMicroarch_Intel_Unknown,
216	/[151(0x97)] = / kCpumMicroarch_Intel_Core7_AlderLake, /* unconfirmed, unreleased */
217	/[152(0x98)] = / kCpumMicroarch_Intel_Unknown,
218	/[153(0x99)] = / kCpumMicroarch_Intel_Unknown,
219	/[154(0x9a)] = / kCpumMicroarch_Intel_Core7_AlderLake, /* unconfirmed, unreleased */
220	/[155(0x9b)] = / kCpumMicroarch_Intel_Unknown,
221	/[156(0x9c)] = / kCpumMicroarch_Intel_Unknown,
222	/[157(0x9d)] = / kCpumMicroarch_Intel_Unknown,
223	/[158(0x9e)] = / kCpumMicroarch_Intel_Core7_KabyLake, /* Stepping >= 0xB is Whiskey Lake, 0xA is CoffeeLake. */
224	/[159(0x9f)] = / kCpumMicroarch_Intel_Unknown,
225	/[160(0xa0)] = / kCpumMicroarch_Intel_Unknown,
226	/[161(0xa1)] = / kCpumMicroarch_Intel_Unknown,
227	/[162(0xa2)] = / kCpumMicroarch_Intel_Unknown,
228	/[163(0xa3)] = / kCpumMicroarch_Intel_Unknown,
229	/[164(0xa4)] = / kCpumMicroarch_Intel_Unknown,
230	/[165(0xa5)] = / kCpumMicroarch_Intel_Core7_CometLake, /* unconfirmed */
231	/[166(0xa6)] = / kCpumMicroarch_Intel_Unknown,
232	/[167(0xa7)] = / kCpumMicroarch_Intel_Core7_CypressCove, /* 14nm backport, unconfirmed */
233	};
234	AssertCompile(RT_ELEMENTS(g_aenmIntelFamily06) == 0xa7+1);
235
236
237	/**
238	* Figures out the (sub-)micro architecture given a bit of CPUID info.
239	*
240	* @returns Micro architecture.
241	* @param enmVendor The CPU vendor.
242	* @param bFamily The CPU family.
243	* @param bModel The CPU model.
244	* @param bStepping The CPU stepping.
245	*/
246	VMMDECL(CPUMMICROARCH) CPUMCpuIdDetermineX86MicroarchEx(CPUMCPUVENDOR enmVendor, uint8_t bFamily,
247	uint8_t bModel, uint8_t bStepping)
248	{
249	if (enmVendor == CPUMCPUVENDOR_AMD)
250	{
251	switch (bFamily)
252	{
253	case 0x02: return kCpumMicroarch_AMD_Am286; /* Not really kosher... */
254	case 0x03: return kCpumMicroarch_AMD_Am386;
255	case 0x23: return kCpumMicroarch_AMD_Am386; /* SX*/
256	case 0x04: return bModel < 14 ? kCpumMicroarch_AMD_Am486 : kCpumMicroarch_AMD_Am486Enh;
257	case 0x05: return bModel < 6 ? kCpumMicroarch_AMD_K5 : kCpumMicroarch_AMD_K6; /* Genode LX is 0x0a, lump it with K6. */
258	case 0x06:
259	switch (bModel)
260	{
261	case 0: return kCpumMicroarch_AMD_K7_Palomino;
262	case 1: return kCpumMicroarch_AMD_K7_Palomino;
263	case 2: return kCpumMicroarch_AMD_K7_Palomino;
264	case 3: return kCpumMicroarch_AMD_K7_Spitfire;
265	case 4: return kCpumMicroarch_AMD_K7_Thunderbird;
266	case 6: return kCpumMicroarch_AMD_K7_Palomino;
267	case 7: return kCpumMicroarch_AMD_K7_Morgan;
268	case 8: return kCpumMicroarch_AMD_K7_Thoroughbred;
269	case 10: return kCpumMicroarch_AMD_K7_Barton; /* Thorton too. */
270	}
271	return kCpumMicroarch_AMD_K7_Unknown;
272	case 0x0f:
273	/*
274	* This family is a friggin mess. Trying my best to make some
275	* sense out of it. Too much happened in the 0x0f family to
276	* lump it all together as K8 (130nm->90nm->65nm, AMD-V, ++).
277	*
278	* Emperical CPUID.01h.EAX evidence from revision guides, wikipedia,
279	* cpu-world.com, and other places:
280	* - 130nm:
281	* - ClawHammer: F7A/SH-CG, F5A/-CG, F4A/-CG, F50/-B0, F48/-C0, F58/-C0,
282	* - SledgeHammer: F50/SH-B0, F48/-C0, F58/-C0, F4A/-CG, F5A/-CG, F7A/-CG, F51/-B3
283	* - Newcastle: FC0/DH-CG (erratum #180: FE0/DH-CG), FF0/DH-CG
284	* - Dublin: FC0/-CG, FF0/-CG, F82/CH-CG, F4A/-CG, F48/SH-C0,
285	* - Odessa: FC0/DH-CG (erratum #180: FE0/DH-CG)
286	* - Paris: FF0/DH-CG, FC0/DH-CG (erratum #180: FE0/DH-CG),
287	* - 90nm:
288	* - Winchester: 10FF0/DH-D0, 20FF0/DH-E3.
289	* - Oakville: 10FC0/DH-D0.
290	* - Georgetown: 10FC0/DH-D0.
291	* - Sonora: 10FC0/DH-D0.
292	* - Venus: 20F71/SH-E4
293	* - Troy: 20F51/SH-E4
294	* - Athens: 20F51/SH-E4
295	* - San Diego: 20F71/SH-E4.
296	* - Lancaster: 20F42/SH-E5
297	* - Newark: 20F42/SH-E5.
298	* - Albany: 20FC2/DH-E6.
299	* - Roma: 20FC2/DH-E6.
300	* - Venice: 20FF0/DH-E3, 20FC2/DH-E6, 20FF2/DH-E6.
301	* - Palermo: 10FC0/DH-D0, 20FF0/DH-E3, 20FC0/DH-E3, 20FC2/DH-E6, 20FF2/DH-E6
302	* - 90nm introducing Dual core:
303	* - Denmark: 20F30/JH-E1, 20F32/JH-E6
304	* - Italy: 20F10/JH-E1, 20F12/JH-E6
305	* - Egypt: 20F10/JH-E1, 20F12/JH-E6
306	* - Toledo: 20F32/JH-E6, 30F72/DH-E6 (single code variant).
307	* - Manchester: 20FB1/BH-E4, 30FF2/BH-E4.
308	* - 90nm 2nd gen opteron ++, AMD-V introduced (might be missing in some cheaper models):
309	* - Santa Ana: 40F32/JH-F2, /-F3
310	* - Santa Rosa: 40F12/JH-F2, 40F13/JH-F3
311	* - Windsor: 40F32/JH-F2, 40F33/JH-F3, C0F13/JH-F3, 40FB2/BH-F2, ??20FB1/BH-E4??.
312	* - Manila: 50FF2/DH-F2, 40FF2/DH-F2
313	* - Orleans: 40FF2/DH-F2, 50FF2/DH-F2, 50FF3/DH-F3.
314	* - Keene: 40FC2/DH-F2.
315	* - Richmond: 40FC2/DH-F2
316	* - Taylor: 40F82/BH-F2
317	* - Trinidad: 40F82/BH-F2
318	*
319	* - 65nm:
320	* - Brisbane: 60FB1/BH-G1, 60FB2/BH-G2.
321	* - Tyler: 60F81/BH-G1, 60F82/BH-G2.
322	* - Sparta: 70FF1/DH-G1, 70FF2/DH-G2.
323	* - Lima: 70FF1/DH-G1, 70FF2/DH-G2.
324	* - Sherman: /-G1, 70FC2/DH-G2.
325	* - Huron: 70FF2/DH-G2.
326	*/
327	if (bModel < 0x10)
328	return kCpumMicroarch_AMD_K8_130nm;
329	if (bModel >= 0x60 && bModel < 0x80)
330	return kCpumMicroarch_AMD_K8_65nm;
331	if (bModel >= 0x40)
332	return kCpumMicroarch_AMD_K8_90nm_AMDV;
333	switch (bModel)
334	{
335	case 0x21:
336	case 0x23:
337	case 0x2b:
338	case 0x2f:
339	case 0x37:
340	case 0x3f:
341	return kCpumMicroarch_AMD_K8_90nm_DualCore;
342	}
343	return kCpumMicroarch_AMD_K8_90nm;
344	case 0x10:
345	return kCpumMicroarch_AMD_K10;
346	case 0x11:
347	return kCpumMicroarch_AMD_K10_Lion;
348	case 0x12:
349	return kCpumMicroarch_AMD_K10_Llano;
350	case 0x14:
351	return kCpumMicroarch_AMD_Bobcat;
352	case 0x15:
353	switch (bModel)
354	{
355	case 0x00: return kCpumMicroarch_AMD_15h_Bulldozer; /* Any? prerelease? */
356	case 0x01: return kCpumMicroarch_AMD_15h_Bulldozer; /* Opteron 4200, FX-81xx. */
357	case 0x02: return kCpumMicroarch_AMD_15h_Piledriver; /* Opteron 4300, FX-83xx. */
358	case 0x10: return kCpumMicroarch_AMD_15h_Piledriver; /* A10-5800K for e.g. */
359	case 0x11: /* ?? */
360	case 0x12: /* ?? */
361	case 0x13: return kCpumMicroarch_AMD_15h_Piledriver; /* A10-6800K for e.g. */
362	}
363	return kCpumMicroarch_AMD_15h_Unknown;
364	case 0x16:
365	return kCpumMicroarch_AMD_Jaguar;
366	case 0x17:
367	return kCpumMicroarch_AMD_Zen_Ryzen;
368	}
369	return kCpumMicroarch_AMD_Unknown;
370	}
371
372	if (enmVendor == CPUMCPUVENDOR_INTEL)
373	{
374	switch (bFamily)
375	{
376	case 3:
377	return kCpumMicroarch_Intel_80386;
378	case 4:
379	return kCpumMicroarch_Intel_80486;
380	case 5:
381	return kCpumMicroarch_Intel_P5;
382	case 6:
383	if (bModel < RT_ELEMENTS(g_aenmIntelFamily06))
384	{
385	CPUMMICROARCH enmMicroArch = g_aenmIntelFamily06[bModel];
386	if (enmMicroArch == kCpumMicroarch_Intel_Core7_KabyLake)
387	{
388	if (bStepping >= 0xa && bStepping <= 0xc)
389	enmMicroArch = kCpumMicroarch_Intel_Core7_CoffeeLake;
390	else if (bStepping >= 0xc)
391	enmMicroArch = kCpumMicroarch_Intel_Core7_WhiskeyLake;
392	}
393	else if ( enmMicroArch == kCpumMicroarch_Intel_Core7_Skylake
394	&& bModel == 0x55
395	&& bStepping >= 5)
396	enmMicroArch = kCpumMicroarch_Intel_Core7_CascadeLake;
397	return enmMicroArch;
398	}
399	return kCpumMicroarch_Intel_Atom_Unknown;
400	case 15:
401	switch (bModel)
402	{
403	case 0: return kCpumMicroarch_Intel_NB_Willamette;
404	case 1: return kCpumMicroarch_Intel_NB_Willamette;
405	case 2: return kCpumMicroarch_Intel_NB_Northwood;
406	case 3: return kCpumMicroarch_Intel_NB_Prescott;
407	case 4: return kCpumMicroarch_Intel_NB_Prescott2M; /* ?? */
408	case 5: return kCpumMicroarch_Intel_NB_Unknown; /??/
409	case 6: return kCpumMicroarch_Intel_NB_CedarMill;
410	case 7: return kCpumMicroarch_Intel_NB_Gallatin;
411	default: return kCpumMicroarch_Intel_NB_Unknown;
412	}
413	break;
414	/* The following are not kosher but kind of follow intuitively from 6, 5 & 4. */
415	case 0:
416	return kCpumMicroarch_Intel_8086;
417	case 1:
418	return kCpumMicroarch_Intel_80186;
419	case 2:
420	return kCpumMicroarch_Intel_80286;
421	}
422	return kCpumMicroarch_Intel_Unknown;
423	}
424
425	if (enmVendor == CPUMCPUVENDOR_VIA)
426	{
427	switch (bFamily)
428	{
429	case 5:
430	switch (bModel)
431	{
432	case 1: return kCpumMicroarch_Centaur_C6;
433	case 4: return kCpumMicroarch_Centaur_C6;
434	case 8: return kCpumMicroarch_Centaur_C2;
435	case 9: return kCpumMicroarch_Centaur_C3;
436	}
437	break;
438
439	case 6:
440	switch (bModel)
441	{
442	case 5: return kCpumMicroarch_VIA_C3_M2;
443	case 6: return kCpumMicroarch_VIA_C3_C5A;
444	case 7: return bStepping < 8 ? kCpumMicroarch_VIA_C3_C5B : kCpumMicroarch_VIA_C3_C5C;
445	case 8: return kCpumMicroarch_VIA_C3_C5N;
446	case 9: return bStepping < 8 ? kCpumMicroarch_VIA_C3_C5XL : kCpumMicroarch_VIA_C3_C5P;
447	case 10: return kCpumMicroarch_VIA_C7_C5J;
448	case 15: return kCpumMicroarch_VIA_Isaiah;
449	}
450	break;
451	}
452	return kCpumMicroarch_VIA_Unknown;
453	}
454
455	if (enmVendor == CPUMCPUVENDOR_SHANGHAI)
456	{
457	switch (bFamily)
458	{
459	case 6:
460	case 7:
461	return kCpumMicroarch_Shanghai_Wudaokou;
462	default:
463	break;
464	}
465	return kCpumMicroarch_Shanghai_Unknown;
466	}
467
468	if (enmVendor == CPUMCPUVENDOR_CYRIX)
469	{
470	switch (bFamily)
471	{
472	case 4:
473	switch (bModel)
474	{
475	case 9: return kCpumMicroarch_Cyrix_5x86;
476	}
477	break;
478
479	case 5:
480	switch (bModel)
481	{
482	case 2: return kCpumMicroarch_Cyrix_M1;
483	case 4: return kCpumMicroarch_Cyrix_MediaGX;
484	case 5: return kCpumMicroarch_Cyrix_MediaGXm;
485	}
486	break;
487
488	case 6:
489	switch (bModel)
490	{
491	case 0: return kCpumMicroarch_Cyrix_M2;
492	}
493	break;
494
495	}
496	return kCpumMicroarch_Cyrix_Unknown;
497	}
498
499	if (enmVendor == CPUMCPUVENDOR_HYGON)
500	{
501	switch (bFamily)
502	{
503	case 0x18:
504	return kCpumMicroarch_Hygon_Dhyana;
505	default:
506	break;
507	}
508	return kCpumMicroarch_Hygon_Unknown;
509	}
510
511	return kCpumMicroarch_Unknown;
512	}
513
514	#endif /* if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86) */
515
516
517
518	/**
519	* Translates a microarchitecture enum value to the corresponding string
520	* constant.
521	*
522	* @returns Read-only string constant (omits "kCpumMicroarch_" prefix). Returns
523	* NULL if the value is invalid.
524	*
525	* @param enmMicroarch The enum value to convert.
526	*/
527	VMMDECL(const char *) CPUMMicroarchName(CPUMMICROARCH enmMicroarch)
528	{
529	switch (enmMicroarch)
530	{
531	#define CASE_RET_STR(enmValue) case enmValue: return #enmValue + (sizeof("kCpumMicroarch_") - 1)
532	CASE_RET_STR(kCpumMicroarch_Intel_8086);
533	CASE_RET_STR(kCpumMicroarch_Intel_80186);
534	CASE_RET_STR(kCpumMicroarch_Intel_80286);
535	CASE_RET_STR(kCpumMicroarch_Intel_80386);
536	CASE_RET_STR(kCpumMicroarch_Intel_80486);
537	CASE_RET_STR(kCpumMicroarch_Intel_P5);
538
539	CASE_RET_STR(kCpumMicroarch_Intel_P6);
540	CASE_RET_STR(kCpumMicroarch_Intel_P6_II);
541	CASE_RET_STR(kCpumMicroarch_Intel_P6_III);
542
543	CASE_RET_STR(kCpumMicroarch_Intel_P6_M_Banias);
544	CASE_RET_STR(kCpumMicroarch_Intel_P6_M_Dothan);
545	CASE_RET_STR(kCpumMicroarch_Intel_Core_Yonah);
546
547	CASE_RET_STR(kCpumMicroarch_Intel_Core2_Merom);
548	CASE_RET_STR(kCpumMicroarch_Intel_Core2_Penryn);
549
550	CASE_RET_STR(kCpumMicroarch_Intel_Core7_Nehalem);
551	CASE_RET_STR(kCpumMicroarch_Intel_Core7_Westmere);
552	CASE_RET_STR(kCpumMicroarch_Intel_Core7_SandyBridge);
553	CASE_RET_STR(kCpumMicroarch_Intel_Core7_IvyBridge);
554	CASE_RET_STR(kCpumMicroarch_Intel_Core7_Haswell);
555	CASE_RET_STR(kCpumMicroarch_Intel_Core7_Broadwell);
556	CASE_RET_STR(kCpumMicroarch_Intel_Core7_Skylake);
557	CASE_RET_STR(kCpumMicroarch_Intel_Core7_KabyLake);
558	CASE_RET_STR(kCpumMicroarch_Intel_Core7_CoffeeLake);
559	CASE_RET_STR(kCpumMicroarch_Intel_Core7_WhiskeyLake);
560	CASE_RET_STR(kCpumMicroarch_Intel_Core7_CascadeLake);
561	CASE_RET_STR(kCpumMicroarch_Intel_Core7_CannonLake);
562	CASE_RET_STR(kCpumMicroarch_Intel_Core7_CometLake);
563	CASE_RET_STR(kCpumMicroarch_Intel_Core7_IceLake);
564	CASE_RET_STR(kCpumMicroarch_Intel_Core7_RocketLake);
565	CASE_RET_STR(kCpumMicroarch_Intel_Core7_TigerLake);
566	CASE_RET_STR(kCpumMicroarch_Intel_Core7_AlderLake);
567	CASE_RET_STR(kCpumMicroarch_Intel_Core7_SapphireRapids);
568
569	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Bonnell);
570	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Lincroft);
571	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Saltwell);
572	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Silvermont);
573	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Airmount);
574	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Goldmont);
575	CASE_RET_STR(kCpumMicroarch_Intel_Atom_GoldmontPlus);
576	CASE_RET_STR(kCpumMicroarch_Intel_Atom_Unknown);
577
578	CASE_RET_STR(kCpumMicroarch_Intel_Phi_KnightsFerry);
579	CASE_RET_STR(kCpumMicroarch_Intel_Phi_KnightsCorner);
580	CASE_RET_STR(kCpumMicroarch_Intel_Phi_KnightsLanding);
581	CASE_RET_STR(kCpumMicroarch_Intel_Phi_KnightsHill);
582	CASE_RET_STR(kCpumMicroarch_Intel_Phi_KnightsMill);
583
584	CASE_RET_STR(kCpumMicroarch_Intel_NB_Willamette);
585	CASE_RET_STR(kCpumMicroarch_Intel_NB_Northwood);
586	CASE_RET_STR(kCpumMicroarch_Intel_NB_Prescott);
587	CASE_RET_STR(kCpumMicroarch_Intel_NB_Prescott2M);
588	CASE_RET_STR(kCpumMicroarch_Intel_NB_CedarMill);
589	CASE_RET_STR(kCpumMicroarch_Intel_NB_Gallatin);
590	CASE_RET_STR(kCpumMicroarch_Intel_NB_Unknown);
591
592	CASE_RET_STR(kCpumMicroarch_Intel_Unknown);
593
594	CASE_RET_STR(kCpumMicroarch_AMD_Am286);
595	CASE_RET_STR(kCpumMicroarch_AMD_Am386);
596	CASE_RET_STR(kCpumMicroarch_AMD_Am486);
597	CASE_RET_STR(kCpumMicroarch_AMD_Am486Enh);
598	CASE_RET_STR(kCpumMicroarch_AMD_K5);
599	CASE_RET_STR(kCpumMicroarch_AMD_K6);
600
601	CASE_RET_STR(kCpumMicroarch_AMD_K7_Palomino);
602	CASE_RET_STR(kCpumMicroarch_AMD_K7_Spitfire);
603	CASE_RET_STR(kCpumMicroarch_AMD_K7_Thunderbird);
604	CASE_RET_STR(kCpumMicroarch_AMD_K7_Morgan);
605	CASE_RET_STR(kCpumMicroarch_AMD_K7_Thoroughbred);
606	CASE_RET_STR(kCpumMicroarch_AMD_K7_Barton);
607	CASE_RET_STR(kCpumMicroarch_AMD_K7_Unknown);
608
609	CASE_RET_STR(kCpumMicroarch_AMD_K8_130nm);
610	CASE_RET_STR(kCpumMicroarch_AMD_K8_90nm);
611	CASE_RET_STR(kCpumMicroarch_AMD_K8_90nm_DualCore);
612	CASE_RET_STR(kCpumMicroarch_AMD_K8_90nm_AMDV);
613	CASE_RET_STR(kCpumMicroarch_AMD_K8_65nm);
614
615	CASE_RET_STR(kCpumMicroarch_AMD_K10);
616	CASE_RET_STR(kCpumMicroarch_AMD_K10_Lion);
617	CASE_RET_STR(kCpumMicroarch_AMD_K10_Llano);
618	CASE_RET_STR(kCpumMicroarch_AMD_Bobcat);
619	CASE_RET_STR(kCpumMicroarch_AMD_Jaguar);
620
621	CASE_RET_STR(kCpumMicroarch_AMD_15h_Bulldozer);
622	CASE_RET_STR(kCpumMicroarch_AMD_15h_Piledriver);
623	CASE_RET_STR(kCpumMicroarch_AMD_15h_Steamroller);
624	CASE_RET_STR(kCpumMicroarch_AMD_15h_Excavator);
625	CASE_RET_STR(kCpumMicroarch_AMD_15h_Unknown);
626
627	CASE_RET_STR(kCpumMicroarch_AMD_16h_First);
628
629	CASE_RET_STR(kCpumMicroarch_AMD_Zen_Ryzen);
630
631	CASE_RET_STR(kCpumMicroarch_AMD_Unknown);
632
633	CASE_RET_STR(kCpumMicroarch_Hygon_Dhyana);
634	CASE_RET_STR(kCpumMicroarch_Hygon_Unknown);
635
636	CASE_RET_STR(kCpumMicroarch_Centaur_C6);
637	CASE_RET_STR(kCpumMicroarch_Centaur_C2);
638	CASE_RET_STR(kCpumMicroarch_Centaur_C3);
639	CASE_RET_STR(kCpumMicroarch_VIA_C3_M2);
640	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5A);
641	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5B);
642	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5C);
643	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5N);
644	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5XL);
645	CASE_RET_STR(kCpumMicroarch_VIA_C3_C5P);
646	CASE_RET_STR(kCpumMicroarch_VIA_C7_C5J);
647	CASE_RET_STR(kCpumMicroarch_VIA_Isaiah);
648	CASE_RET_STR(kCpumMicroarch_VIA_Unknown);
649
650	CASE_RET_STR(kCpumMicroarch_Shanghai_Wudaokou);
651	CASE_RET_STR(kCpumMicroarch_Shanghai_Unknown);
652
653	CASE_RET_STR(kCpumMicroarch_Cyrix_5x86);
654	CASE_RET_STR(kCpumMicroarch_Cyrix_M1);
655	CASE_RET_STR(kCpumMicroarch_Cyrix_MediaGX);
656	CASE_RET_STR(kCpumMicroarch_Cyrix_MediaGXm);
657	CASE_RET_STR(kCpumMicroarch_Cyrix_M2);
658	CASE_RET_STR(kCpumMicroarch_Cyrix_Unknown);
659
660	CASE_RET_STR(kCpumMicroarch_NEC_V20);
661	CASE_RET_STR(kCpumMicroarch_NEC_V30);
662
663	CASE_RET_STR(kCpumMicroarch_Apple_M1);
664	CASE_RET_STR(kCpumMicroarch_Apple_M2);
665	CASE_RET_STR(kCpumMicroarch_Apple_M3);
666	CASE_RET_STR(kCpumMicroarch_Apple_M4);
667
668	CASE_RET_STR(kCpumMicroarch_Qualcomm_Kyro);
669	CASE_RET_STR(kCpumMicroarch_Qualcomm_Oryon);
670
671	CASE_RET_STR(kCpumMicroarch_Unknown);
672
673	#undef CASE_RET_STR
674	case kCpumMicroarch_Invalid:
675	case kCpumMicroarch_Intel_End:
676	case kCpumMicroarch_Intel_Core2_End:
677	case kCpumMicroarch_Intel_Core7_End:
678	case kCpumMicroarch_Intel_Atom_End:
679	case kCpumMicroarch_Intel_P6_Core_Atom_End:
680	case kCpumMicroarch_Intel_Phi_End:
681	case kCpumMicroarch_Intel_NB_End:
682	case kCpumMicroarch_AMD_K7_End:
683	case kCpumMicroarch_AMD_K8_End:
684	case kCpumMicroarch_AMD_15h_End:
685	case kCpumMicroarch_AMD_16h_End:
686	case kCpumMicroarch_AMD_Zen_End:
687	case kCpumMicroarch_AMD_End:
688	case kCpumMicroarch_Hygon_End:
689	case kCpumMicroarch_VIA_End:
690	case kCpumMicroarch_Shanghai_End:
691	case kCpumMicroarch_Cyrix_End:
692	case kCpumMicroarch_NEC_End:
693	case kCpumMicroarch_Apple_End:
694	case kCpumMicroarch_Qualcomm_End:
695	case kCpumMicroarch_32BitHack:
696	break;
697	/* no default! */
698	}
699
700	return NULL;
701	}
702
703	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86)
704
705	/**
706	* Gets a matching leaf in the CPUID leaf array.
707	*
708	* @returns Pointer to the matching leaf, or NULL if not found.
709	* @param paLeaves The CPUID leaves to search. This is sorted.
710	* @param cLeaves The number of leaves in the array.
711	* @param uLeaf The leaf to locate.
712	* @param uSubLeaf The subleaf to locate. Pass 0 if no sub-leaves.
713	*/
714	PCPUMCPUIDLEAF cpumCpuIdGetLeafInt(PCPUMCPUIDLEAF paLeaves, uint32_t cLeaves, uint32_t uLeaf, uint32_t uSubLeaf)
715	{
716	/* Lazy bird does linear lookup here since this is only used for the
717	occational CPUID overrides. */
718	for (uint32_t i = 0; i < cLeaves; i++)
719	if ( paLeaves[i].uLeaf == uLeaf
720	&& paLeaves[i].uSubLeaf == (uSubLeaf & paLeaves[i].fSubLeafMask))
721	return &paLeaves[i];
722	return NULL;
723	}
724
725
726	/**
727	* Ensures that the CPUID leaf array can hold one more leaf.
728	*
729	* @returns Pointer to the CPUID leaf array (*ppaLeaves) on success. NULL on
730	* failure.
731	* @param pVM The cross context VM structure. If NULL, use
732	* the process heap, otherwise the VM's hyper heap.
733	* @param ppaLeaves Pointer to the variable holding the array pointer
734	* (input/output).
735	* @param cLeaves The current array size.
736	*
737	* @remarks This function will automatically update the R0 and RC pointers when
738	* using the hyper heap, which means @a ppaLeaves and @a cLeaves must
739	* be the corresponding VM's CPUID arrays (which is asserted).
740	*/
741	PCPUMCPUIDLEAF cpumCpuIdEnsureSpace(PVM pVM, PCPUMCPUIDLEAF *ppaLeaves, uint32_t cLeaves)
742	{
743	/*
744	* If pVM is not specified, we're on the regular heap and can waste a
745	* little space to speed things up.
746	*/
747	uint32_t cAllocated;
748	if (!pVM)
749	{
750	cAllocated = RT_ALIGN(cLeaves, 16);
751	if (cLeaves + 1 > cAllocated)
752	{
753	void pvNew = RTMemRealloc(ppaLeaves, (cAllocated + 16) * sizeof(**ppaLeaves));
754	if (pvNew)
755	*ppaLeaves = (PCPUMCPUIDLEAF)pvNew;
756	else
757	{
758	RTMemFree(*ppaLeaves);
759	*ppaLeaves = NULL;
760	}
761	}
762	}
763	/*
764	* Otherwise, we're on the hyper heap and are probably just inserting
765	* one or two leaves and should conserve space.
766	*/
767	else
768	{
769	# if defined(IN_VBOX_CPU_REPORT) \|\| !defined(VBOX_VMM_TARGET_X86)
770	AssertReleaseFailed();
771	# else
772	# ifdef IN_RING3
773	Assert(ppaLeaves == &pVM->cpum.s.GuestInfo.paCpuIdLeavesR3);
774	Assert(*ppaLeaves == pVM->cpum.s.GuestInfo.aCpuIdLeaves);
775	Assert(cLeaves == pVM->cpum.s.GuestInfo.cCpuIdLeaves);
776
777	if (cLeaves + 1 <= RT_ELEMENTS(pVM->cpum.s.GuestInfo.aCpuIdLeaves))
778	{ }
779	else
780	# endif
781	{
782	*ppaLeaves = NULL;
783	LogRel(("CPUM: cpumR3CpuIdEnsureSpace: Out of CPUID space!\n"));
784	}
785	# endif
786	}
787	return *ppaLeaves;
788	}
789
790
791	# ifdef VBOX_STRICT
792	/**
793	* Checks that we've updated the CPUID leaves array correctly.
794	*
795	* This is a no-op in non-strict builds.
796	*
797	* @param paLeaves The leaves array.
798	* @param cLeaves The number of leaves.
799	*/
800	void cpumCpuIdAssertOrder(PCPUMCPUIDLEAF paLeaves, uint32_t cLeaves)
801	{
802	for (uint32_t i = 1; i < cLeaves; i++)
803	if (paLeaves[i].uLeaf != paLeaves[i - 1].uLeaf)
804	AssertMsg(paLeaves[i].uLeaf > paLeaves[i - 1].uLeaf, ("%#x vs %#x\n", paLeaves[i].uLeaf, paLeaves[i - 1].uLeaf));
805	else
806	{
807	AssertMsg(paLeaves[i].uSubLeaf > paLeaves[i - 1].uSubLeaf,
808	("%#x: %#x vs %#x\n", paLeaves[i].uLeaf, paLeaves[i].uSubLeaf, paLeaves[i - 1].uSubLeaf));
809	AssertMsg(paLeaves[i].fSubLeafMask == paLeaves[i - 1].fSubLeafMask,
810	("%#x/%#x: %#x vs %#x\n", paLeaves[i].uLeaf, paLeaves[i].uSubLeaf, paLeaves[i].fSubLeafMask, paLeaves[i - 1].fSubLeafMask));
811	AssertMsg(paLeaves[i].fFlags == paLeaves[i - 1].fFlags,
812	("%#x/%#x: %#x vs %#x\n", paLeaves[i].uLeaf, paLeaves[i].uSubLeaf, paLeaves[i].fFlags, paLeaves[i - 1].fFlags));
813	}
814	}
815	# endif
816
817	#endif /* defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86) */
818
819	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64)
820
821	/**
822	* Append a CPUID leaf or sub-leaf.
823	*
824	* ASSUMES linear insertion order, so we'll won't need to do any searching or
825	* replace anything. Use cpumR3CpuIdInsert() for those cases.
826	*
827	* @returns VINF_SUCCESS or VERR_NO_MEMORY. On error, *ppaLeaves is freed, so
828	* the caller need do no more work.
829	* @param ppaLeaves Pointer to the pointer to the array of sorted
830	* CPUID leaves and sub-leaves.
831	* @param pcLeaves Where we keep the leaf count for *ppaLeaves.
832	* @param uLeaf The leaf we're adding.
833	* @param uSubLeaf The sub-leaf number.
834	* @param fSubLeafMask The sub-leaf mask.
835	* @param uEax The EAX value.
836	* @param uEbx The EBX value.
837	* @param uEcx The ECX value.
838	* @param uEdx The EDX value.
839	* @param fFlags The flags.
840	*/
841	static int cpumCollectCpuIdInfoAddOne(PCPUMCPUIDLEAF ppaLeaves, uint32_t pcLeaves,
842	uint32_t uLeaf, uint32_t uSubLeaf, uint32_t fSubLeafMask,
843	uint32_t uEax, uint32_t uEbx, uint32_t uEcx, uint32_t uEdx, uint32_t fFlags)
844	{
845	if (!cpumCpuIdEnsureSpace(NULL /* pVM /, ppaLeaves, pcLeaves))
846	return VERR_NO_MEMORY;
847
848	PCPUMCPUIDLEAF pNew = &(ppaLeaves)[pcLeaves];
849	Assert( *pcLeaves == 0
850	\|\| pNew[-1].uLeaf < uLeaf
851	\|\| (pNew[-1].uLeaf == uLeaf && pNew[-1].uSubLeaf < uSubLeaf) );
852
853	pNew->uLeaf = uLeaf;
854	pNew->uSubLeaf = uSubLeaf;
855	pNew->fSubLeafMask = fSubLeafMask;
856	pNew->uEax = uEax;
857	pNew->uEbx = uEbx;
858	pNew->uEcx = uEcx;
859	pNew->uEdx = uEdx;
860	pNew->fFlags = fFlags;
861
862	*pcLeaves += 1;
863	return VINF_SUCCESS;
864	}
865
866
867	/**
868	* Checks if ECX make a difference when reading a given CPUID leaf.
869	*
870	* @returns @c true if it does, @c false if it doesn't.
871	* @param uLeaf The leaf we're reading.
872	* @param pcSubLeaves Number of sub-leaves accessible via ECX.
873	* @param pfFinalEcxUnchanged Whether ECX is passed thru when going beyond the
874	* final sub-leaf (for leaf 0xb only).
875	*/
876	static bool cpumIsEcxRelevantForCpuIdLeaf(uint32_t uLeaf, uint32_t pcSubLeaves, bool pfFinalEcxUnchanged)
877	{
878	*pfFinalEcxUnchanged = false;
879
880	uint32_t auCur[4];
881	uint32_t auPrev[4];
882	ASMCpuIdExSlow(uLeaf, 0, 0, 0, &auPrev[0], &auPrev[1], &auPrev[2], &auPrev[3]);
883
884	/* Look for sub-leaves. */
885	uint32_t uSubLeaf = 1;
886	for (;;)
887	{
888	ASMCpuIdExSlow(uLeaf, 0, uSubLeaf, 0, &auCur[0], &auCur[1], &auCur[2], &auCur[3]);
889	if (memcmp(auCur, auPrev, sizeof(auCur)))
890	break;
891
892	/* Advance / give up. */
893	uSubLeaf++;
894	if (uSubLeaf >= 64)
895	{
896	*pcSubLeaves = 1;
897	return false;
898	}
899	}
900
901	/* Count sub-leaves. */
902	uint32_t cMinLeaves = uLeaf == 0xd ? 64 : uLeaf == 7 ? 2 : 0;
903	uint32_t cRepeats = 0;
904	uSubLeaf = 0;
905	for (;;)
906	{
907	ASMCpuIdExSlow(uLeaf, 0, uSubLeaf, 0, &auCur[0], &auCur[1], &auCur[2], &auCur[3]);
908
909	/* Figuring out when to stop isn't entirely straight forward as we need
910	to cover undocumented behavior up to a point and implementation shortcuts. */
911
912	/* 1. Look for more than 4 repeating value sets. */
913	if ( auCur[0] == auPrev[0]
914	&& auCur[1] == auPrev[1]
915	&& ( auCur[2] == auPrev[2]
916	\|\| ( auCur[2] == uSubLeaf
917	&& auPrev[2] == uSubLeaf - 1) )
918	&& auCur[3] == auPrev[3])
919	{
920	if ( uLeaf != 0xd
921	\|\| uSubLeaf >= 64
922	\|\| ( auCur[0] == 0
923	&& auCur[1] == 0
924	&& auCur[2] == 0
925	&& auCur[3] == 0
926	&& auPrev[2] == 0) )
927	cRepeats++;
928	if (cRepeats > 4 && uSubLeaf >= cMinLeaves)
929	break;
930	}
931	else
932	cRepeats = 0;
933
934	/* 2. Look for zero values. */
935	if ( auCur[0] == 0
936	&& auCur[1] == 0
937	&& (auCur[2] == 0 \|\| auCur[2] == uSubLeaf)
938	&& (auCur[3] == 0 \|\| uLeaf == 0xb /* edx is fixed */)
939	&& uSubLeaf >= cMinLeaves)
940	{
941	cRepeats = 0;
942	break;
943	}
944
945	/* 3. Leaf 0xb level type 0 check. */
946	if ( uLeaf == 0xb
947	&& (auCur[2] & 0xff00) == 0
948	&& (auPrev[2] & 0xff00) == 0)
949	{
950	cRepeats = 0;
951	break;
952	}
953
954	/* 99. Give up. */
955	if (uSubLeaf >= 128)
956	{
957	# ifndef IN_VBOX_CPU_REPORT
958	/* Ok, limit it according to the documentation if possible just to
959	avoid annoying users with these detection issues. */
960	uint32_t cDocLimit = UINT32_MAX;
961	if (uLeaf == 0x4)
962	cDocLimit = 4;
963	else if (uLeaf == 0x7)
964	cDocLimit = 1;
965	else if (uLeaf == 0xd)
966	cDocLimit = 63;
967	else if (uLeaf == 0xf)
968	cDocLimit = 2;
969	if (cDocLimit != UINT32_MAX)
970	{
971	*pfFinalEcxUnchanged = auCur[2] == uSubLeaf && uLeaf == 0xb;
972	*pcSubLeaves = cDocLimit + 3;
973	return true;
974	}
975	# endif
976	*pcSubLeaves = UINT32_MAX;
977	return true;
978	}
979
980	/* Advance. */
981	uSubLeaf++;
982	memcpy(auPrev, auCur, sizeof(auCur));
983	}
984
985	/* Standard exit. */
986	*pfFinalEcxUnchanged = auCur[2] == uSubLeaf && uLeaf == 0xb;
987	*pcSubLeaves = uSubLeaf + 1 - cRepeats;
988	if (*pcSubLeaves == 0)
989	*pcSubLeaves = 1;
990	return true;
991	}
992
993
994	/**
995	* Collects CPUID leaves and sub-leaves, returning a sorted array of them.
996	*
997	* @returns VBox status code.
998	* @param ppaLeaves Where to return the array pointer on success.
999	* Use RTMemFree to release.
1000	* @param pcLeaves Where to return the size of the array on
1001	* success.
1002	*/
1003	VMMDECL(int) CPUMCpuIdCollectLeavesFromX86Host(PCPUMCPUIDLEAF ppaLeaves, uint32_t pcLeaves)
1004	{
1005	*ppaLeaves = NULL;
1006	*pcLeaves = 0;
1007
1008	/*
1009	* Try out various candidates. This must be sorted!
1010	*/
1011	static struct { uint32_t uMsr; bool fSpecial; } const s_aCandidates[] =
1012	{
1013	{ UINT32_C(0x00000000), false },
1014	{ UINT32_C(0x10000000), false },
1015	{ UINT32_C(0x20000000), false },
1016	{ UINT32_C(0x30000000), false },
1017	{ UINT32_C(0x40000000), false },
1018	{ UINT32_C(0x50000000), false },
1019	{ UINT32_C(0x60000000), false },
1020	{ UINT32_C(0x70000000), false },
1021	{ UINT32_C(0x80000000), false },
1022	{ UINT32_C(0x80860000), false },
1023	{ UINT32_C(0x8ffffffe), true },
1024	{ UINT32_C(0x8fffffff), true },
1025	{ UINT32_C(0x90000000), false },
1026	{ UINT32_C(0xa0000000), false },
1027	{ UINT32_C(0xb0000000), false },
1028	{ UINT32_C(0xc0000000), false },
1029	{ UINT32_C(0xd0000000), false },
1030	{ UINT32_C(0xe0000000), false },
1031	{ UINT32_C(0xf0000000), false },
1032	};
1033
1034	for (uint32_t iOuter = 0; iOuter < RT_ELEMENTS(s_aCandidates); iOuter++)
1035	{
1036	uint32_t uLeaf = s_aCandidates[iOuter].uMsr;
1037	uint32_t uEax, uEbx, uEcx, uEdx;
1038	ASMCpuIdExSlow(uLeaf, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
1039
1040	/*
1041	* Does EAX look like a typical leaf count value?
1042	*/
1043	if ( uEax > uLeaf
1044	&& uEax - uLeaf < UINT32_C(0xff)) /* Adjust 0xff limit when exceeded by real HW. */
1045	{
1046	/* Yes, dump them. */
1047	uint32_t cLeaves = uEax - uLeaf + 1;
1048	while (cLeaves-- > 0)
1049	{
1050	ASMCpuIdExSlow(uLeaf, 0, 0, 0, &uEax, &uEbx, &uEcx, &uEdx);
1051
1052	uint32_t fFlags = 0;
1053
1054	/* There are currently three known leaves containing an APIC ID
1055	that needs EMT specific attention */
1056	if (uLeaf == 1)
1057	fFlags \|= CPUMCPUIDLEAF_F_CONTAINS_APIC_ID;
1058	else if (uLeaf == 0xb && uEcx != 0)
1059	fFlags \|= CPUMCPUIDLEAF_F_CONTAINS_APIC_ID;
1060	else if ( uLeaf == UINT32_C(0x8000001e)
1061	&& ( uEax
1062	\|\| uEbx
1063	\|\| uEdx
1064	\|\| RTX86IsAmdCpu((ppaLeaves)[0].uEbx, (ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
1065	\|\| RTX86IsHygonCpu((ppaLeaves)[0].uEbx, (ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
1066	fFlags \|= CPUMCPUIDLEAF_F_CONTAINS_APIC_ID;
1067
1068	/* The APIC bit is per-VCpu and needs flagging. */
1069	if (uLeaf == 1)
1070	fFlags \|= CPUMCPUIDLEAF_F_CONTAINS_APIC;
1071	else if ( uLeaf == UINT32_C(0x80000001)
1072	&& ( (uEdx & X86_CPUID_AMD_FEATURE_EDX_APIC)
1073	\|\| RTX86IsAmdCpu((ppaLeaves)[0].uEbx, (ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)
1074	\|\| RTX86IsHygonCpu((ppaLeaves)[0].uEbx, (ppaLeaves)[0].uEcx, (*ppaLeaves)[0].uEdx)) )
1075	fFlags \|= CPUMCPUIDLEAF_F_CONTAINS_APIC;
1076
1077	/* Check three times here to reduce the chance of CPU migration
1078	resulting in false positives with things like the APIC ID. */
1079	uint32_t cSubLeaves;
1080	bool fFinalEcxUnchanged;
1081	if ( cpumIsEcxRelevantForCpuIdLeaf(uLeaf, &cSubLeaves, &fFinalEcxUnchanged)
1082	&& cpumIsEcxRelevantForCpuIdLeaf(uLeaf, &cSubLeaves, &fFinalEcxUnchanged)
1083	&& cpumIsEcxRelevantForCpuIdLeaf(uLeaf, &cSubLeaves, &fFinalEcxUnchanged))
1084	{
1085	if (cSubLeaves > (uLeaf == 0xd ? 68U : 16U))
1086	{
1087	/* This shouldn't happen. But in case it does, file all
1088	relevant details in the release log. */
1089	LogRel(("CPUM: VERR_CPUM_TOO_MANY_CPUID_SUBLEAVES! uLeaf=%#x cSubLeaves=%#x\n", uLeaf, cSubLeaves));
1090	LogRel(("------------------ dump of problematic sub-leaves -----------------\n"));
1091	for (uint32_t uSubLeaf = 0; uSubLeaf < 128; uSubLeaf++)
1092	{
1093	uint32_t auTmp[4];
1094	ASMCpuIdExSlow(uLeaf, 0, uSubLeaf, 0, &auTmp[0], &auTmp[1], &auTmp[2], &auTmp[3]);
1095	LogRel(("CPUM: %#010x, %#010x => %#010x %#010x %#010x %#010x\n",
1096	uLeaf, uSubLeaf, auTmp[0], auTmp[1], auTmp[2], auTmp[3]));
1097	}
1098	LogRel(("----------------- dump of what we've found so far -----------------\n"));
1099	for (uint32_t i = 0 ; i < *pcLeaves; i++)
1100	LogRel(("CPUM: %#010x, %#010x/%#010x => %#010x %#010x %#010x %#010x\n",
1101	(ppaLeaves)[i].uLeaf, (ppaLeaves)[i].uSubLeaf, (*ppaLeaves)[i].fSubLeafMask,
1102	(ppaLeaves)[i].uEax, (ppaLeaves)[i].uEbx, (ppaLeaves)[i].uEcx, (ppaLeaves)[i].uEdx));
1103	LogRel(("\nPlease create a defect on virtualbox.org and attach this log file!\n\n"));
1104	return VERR_CPUM_TOO_MANY_CPUID_SUBLEAVES;
1105	}
1106
1107	if (fFinalEcxUnchanged)
1108	fFlags \|= CPUMCPUIDLEAF_F_INTEL_TOPOLOGY_SUBLEAVES;
1109
1110	for (uint32_t uSubLeaf = 0; uSubLeaf < cSubLeaves; uSubLeaf++)
1111	{
1112	ASMCpuIdExSlow(uLeaf, 0, uSubLeaf, 0, &uEax, &uEbx, &uEcx, &uEdx);
1113	int rc = cpumCollectCpuIdInfoAddOne(ppaLeaves, pcLeaves,
1114	uLeaf, uSubLeaf, UINT32_MAX, uEax, uEbx, uEcx, uEdx, fFlags);
1115	if (RT_FAILURE(rc))
1116	return rc;
1117	}
1118	}
1119	else
1120	{
1121	int rc = cpumCollectCpuIdInfoAddOne(ppaLeaves, pcLeaves, uLeaf, 0, 0, uEax, uEbx, uEcx, uEdx, fFlags);
1122	if (RT_FAILURE(rc))
1123	return rc;
1124	}
1125
1126	/* next */
1127	uLeaf++;
1128	}
1129	}
1130	/*
1131	* Special CPUIDs needs special handling as they don't follow the
1132	* leaf count principle used above.
1133	*/
1134	else if (s_aCandidates[iOuter].fSpecial)
1135	{
1136	bool fKeep = false;
1137	if (uLeaf == 0x8ffffffe && uEax == UINT32_C(0x00494544))
1138	fKeep = true;
1139	else if ( uLeaf == 0x8fffffff
1140	&& RT_C_IS_PRINT(RT_BYTE1(uEax))
1141	&& RT_C_IS_PRINT(RT_BYTE2(uEax))
1142	&& RT_C_IS_PRINT(RT_BYTE3(uEax))
1143	&& RT_C_IS_PRINT(RT_BYTE4(uEax))
1144	&& RT_C_IS_PRINT(RT_BYTE1(uEbx))
1145	&& RT_C_IS_PRINT(RT_BYTE2(uEbx))
1146	&& RT_C_IS_PRINT(RT_BYTE3(uEbx))
1147	&& RT_C_IS_PRINT(RT_BYTE4(uEbx))
1148	&& RT_C_IS_PRINT(RT_BYTE1(uEcx))
1149	&& RT_C_IS_PRINT(RT_BYTE2(uEcx))
1150	&& RT_C_IS_PRINT(RT_BYTE3(uEcx))
1151	&& RT_C_IS_PRINT(RT_BYTE4(uEcx))
1152	&& RT_C_IS_PRINT(RT_BYTE1(uEdx))
1153	&& RT_C_IS_PRINT(RT_BYTE2(uEdx))
1154	&& RT_C_IS_PRINT(RT_BYTE3(uEdx))
1155	&& RT_C_IS_PRINT(RT_BYTE4(uEdx)) )
1156	fKeep = true;
1157	if (fKeep)
1158	{
1159	int rc = cpumCollectCpuIdInfoAddOne(ppaLeaves, pcLeaves, uLeaf, 0, 0, uEax, uEbx, uEcx, uEdx, 0);
1160	if (RT_FAILURE(rc))
1161	return rc;
1162	}
1163	}
1164	}
1165
1166	# ifdef VBOX_STRICT
1167	cpumCpuIdAssertOrder(ppaLeaves, pcLeaves);
1168	# endif
1169	return VINF_SUCCESS;
1170	}
1171
1172	#endif /* RT_ARCH_X86 \|\| RT_ARCH_AMD64 */
1173
1174	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86)
1175	/**
1176	* Detect the CPU vendor give n the
1177	*
1178	* @returns The vendor.
1179	* @param uEAX EAX from CPUID(0).
1180	* @param uEBX EBX from CPUID(0).
1181	* @param uECX ECX from CPUID(0).
1182	* @param uEDX EDX from CPUID(0).
1183	*/
1184	VMMDECL(CPUMCPUVENDOR) CPUMCpuIdDetectX86VendorEx(uint32_t uEAX, uint32_t uEBX, uint32_t uECX, uint32_t uEDX)
1185	{
1186	if (RTX86IsValidStdRange(uEAX))
1187	{
1188	if (RTX86IsAmdCpu(uEBX, uECX, uEDX))
1189	return CPUMCPUVENDOR_AMD;
1190
1191	if (RTX86IsIntelCpu(uEBX, uECX, uEDX))
1192	return CPUMCPUVENDOR_INTEL;
1193
1194	if (RTX86IsViaCentaurCpu(uEBX, uECX, uEDX))
1195	return CPUMCPUVENDOR_VIA;
1196
1197	if (RTX86IsShanghaiCpu(uEBX, uECX, uEDX))
1198	return CPUMCPUVENDOR_SHANGHAI;
1199
1200	if ( uEBX == UINT32_C(0x69727943) /* CyrixInstead */
1201	&& uECX == UINT32_C(0x64616574)
1202	&& uEDX == UINT32_C(0x736E4978))
1203	return CPUMCPUVENDOR_CYRIX;
1204
1205	if (RTX86IsHygonCpu(uEBX, uECX, uEDX))
1206	return CPUMCPUVENDOR_HYGON;
1207
1208	/* "Geode by NSC", example: family 5, model 9. */
1209
1210	/** @todo detect the other buggers... */
1211	}
1212
1213	return CPUMCPUVENDOR_UNKNOWN;
1214	}
1215	#endif /* defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86) */
1216
1217
1218	/**
1219	* Translates a CPU vendor enum value into the corresponding string constant.
1220	*
1221	* The named can be prefixed with 'CPUMCPUVENDOR_' to construct a valid enum
1222	* value name. This can be useful when generating code.
1223	*
1224	* @returns Read only name string.
1225	* @param enmVendor The CPU vendor value.
1226	*/
1227	VMMDECL(const char *) CPUMCpuVendorName(CPUMCPUVENDOR enmVendor)
1228	{
1229	switch (enmVendor)
1230	{
1231	case CPUMCPUVENDOR_INTEL: return "INTEL";
1232	case CPUMCPUVENDOR_AMD: return "AMD";
1233	case CPUMCPUVENDOR_VIA: return "VIA";
1234	case CPUMCPUVENDOR_CYRIX: return "CYRIX";
1235	case CPUMCPUVENDOR_SHANGHAI: return "SHANGHAI";
1236	case CPUMCPUVENDOR_HYGON: return "HYGON";
1237
1238	case CPUMCPUVENDOR_ARM: return "ARM";
1239	case CPUMCPUVENDOR_BROADCOM: return "Broadcom";
1240	case CPUMCPUVENDOR_QUALCOMM: return "Qualecomm";
1241	case CPUMCPUVENDOR_APPLE: return "Apple";
1242	case CPUMCPUVENDOR_AMPERE: return "Ampere";
1243
1244	case CPUMCPUVENDOR_UNKNOWN: return "UNKNOWN";
1245
1246	case CPUMCPUVENDOR_INVALID:
1247	case CPUMCPUVENDOR_32BIT_HACK:
1248	break;
1249	}
1250	return "Invalid-cpu-vendor";
1251	}
1252
1253	#if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86)
1254
1255	static PCCPUMCPUIDLEAF cpumCpuIdFindLeaf(PCCPUMCPUIDLEAF paLeaves, uint32_t cLeaves, uint32_t uLeaf)
1256	{
1257	/* Could do binary search, doing linear now because I'm lazy. */
1258	PCCPUMCPUIDLEAF pLeaf = paLeaves;
1259	while (cLeaves-- > 0)
1260	{
1261	if (pLeaf->uLeaf == uLeaf)
1262	return pLeaf;
1263	pLeaf++;
1264	}
1265	return NULL;
1266	}
1267
1268
1269	static PCCPUMCPUIDLEAF cpumCpuIdFindLeafEx(PCCPUMCPUIDLEAF paLeaves, uint32_t cLeaves, uint32_t uLeaf, uint32_t uSubLeaf)
1270	{
1271	PCCPUMCPUIDLEAF pLeaf = cpumCpuIdFindLeaf(paLeaves, cLeaves, uLeaf);
1272	if ( !pLeaf
1273	\|\| pLeaf->uSubLeaf != (uSubLeaf & pLeaf->fSubLeafMask))
1274	return pLeaf;
1275
1276	/* Linear sub-leaf search. Lazy as usual. */
1277	cLeaves -= pLeaf - paLeaves;
1278	while ( cLeaves-- > 0
1279	&& pLeaf->uLeaf == uLeaf)
1280	{
1281	if (pLeaf->uSubLeaf == (uSubLeaf & pLeaf->fSubLeafMask))
1282	return pLeaf;
1283	pLeaf++;
1284	}
1285
1286	return NULL;
1287	}
1288
1289
1290	static void cpumExplodeVmxFeatures(PCVMXMSRS pVmxMsrs, CPUMFEATURESX86 *pFeatures)
1291	{
1292	Assert(pVmxMsrs);
1293	Assert(pFeatures);
1294	Assert(pFeatures->fVmx);
1295
1296	/* Basic information. */
1297	bool const fVmxTrueMsrs = RT_BOOL(pVmxMsrs->u64Basic & VMX_BF_BASIC_TRUE_CTLS_MASK);
1298	{
1299	uint64_t const u64Basic = pVmxMsrs->u64Basic;
1300	pFeatures->fVmxInsOutInfo = RT_BF_GET(u64Basic, VMX_BF_BASIC_VMCS_INS_OUTS);
1301	}
1302
1303	/* Pin-based VM-execution controls. */
1304	{
1305	uint32_t const fPinCtls = fVmxTrueMsrs ? pVmxMsrs->TruePinCtls.n.allowed1 : pVmxMsrs->PinCtls.n.allowed1;
1306	pFeatures->fVmxExtIntExit = RT_BOOL(fPinCtls & VMX_PIN_CTLS_EXT_INT_EXIT);
1307	pFeatures->fVmxNmiExit = RT_BOOL(fPinCtls & VMX_PIN_CTLS_NMI_EXIT);
1308	pFeatures->fVmxVirtNmi = RT_BOOL(fPinCtls & VMX_PIN_CTLS_VIRT_NMI);
1309	pFeatures->fVmxPreemptTimer = RT_BOOL(fPinCtls & VMX_PIN_CTLS_PREEMPT_TIMER);
1310	pFeatures->fVmxPostedInt = RT_BOOL(fPinCtls & VMX_PIN_CTLS_POSTED_INT);
1311	}
1312
1313	/* Processor-based VM-execution controls. */
1314	{
1315	uint32_t const fProcCtls = fVmxTrueMsrs ? pVmxMsrs->TrueProcCtls.n.allowed1 : pVmxMsrs->ProcCtls.n.allowed1;
1316	pFeatures->fVmxIntWindowExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_INT_WINDOW_EXIT);
1317	pFeatures->fVmxTscOffsetting = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_TSC_OFFSETTING);
1318	pFeatures->fVmxHltExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_HLT_EXIT);
1319	pFeatures->fVmxInvlpgExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_INVLPG_EXIT);
1320	pFeatures->fVmxMwaitExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_MWAIT_EXIT);
1321	pFeatures->fVmxRdpmcExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_RDPMC_EXIT);
1322	pFeatures->fVmxRdtscExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_RDTSC_EXIT);
1323	pFeatures->fVmxCr3LoadExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_CR3_LOAD_EXIT);
1324	pFeatures->fVmxCr3StoreExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_CR3_STORE_EXIT);
1325	pFeatures->fVmxTertiaryExecCtls = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_TERTIARY_CTLS);
1326	pFeatures->fVmxCr8LoadExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_CR8_LOAD_EXIT);
1327	pFeatures->fVmxCr8StoreExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_CR8_STORE_EXIT);
1328	pFeatures->fVmxUseTprShadow = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_TPR_SHADOW);
1329	pFeatures->fVmxNmiWindowExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_NMI_WINDOW_EXIT);
1330	pFeatures->fVmxMovDRxExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_MOV_DR_EXIT);
1331	pFeatures->fVmxUncondIoExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_UNCOND_IO_EXIT);
1332	pFeatures->fVmxUseIoBitmaps = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_IO_BITMAPS);
1333	pFeatures->fVmxMonitorTrapFlag = RT_BOOL(fProcCtls & VMX_PROC_CTLS_MONITOR_TRAP_FLAG);
1334	pFeatures->fVmxUseMsrBitmaps = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_MSR_BITMAPS);
1335	pFeatures->fVmxMonitorExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_MONITOR_EXIT);
1336	pFeatures->fVmxPauseExit = RT_BOOL(fProcCtls & VMX_PROC_CTLS_PAUSE_EXIT);
1337	pFeatures->fVmxSecondaryExecCtls = RT_BOOL(fProcCtls & VMX_PROC_CTLS_USE_SECONDARY_CTLS);
1338	}
1339
1340	/* Secondary processor-based VM-execution controls. */
1341	{
1342	uint32_t const fProcCtls2 = pFeatures->fVmxSecondaryExecCtls ? pVmxMsrs->ProcCtls2.n.allowed1 : 0;
1343	pFeatures->fVmxVirtApicAccess = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VIRT_APIC_ACCESS);
1344	pFeatures->fVmxEpt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_EPT);
1345	pFeatures->fVmxDescTableExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_DESC_TABLE_EXIT);
1346	pFeatures->fVmxRdtscp = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_RDTSCP);
1347	pFeatures->fVmxVirtX2ApicMode = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VIRT_X2APIC_MODE);
1348	pFeatures->fVmxVpid = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VPID);
1349	pFeatures->fVmxWbinvdExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_WBINVD_EXIT);
1350	pFeatures->fVmxUnrestrictedGuest = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_UNRESTRICTED_GUEST);
1351	pFeatures->fVmxApicRegVirt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_APIC_REG_VIRT);
1352	pFeatures->fVmxVirtIntDelivery = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VIRT_INT_DELIVERY);
1353	pFeatures->fVmxPauseLoopExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_PAUSE_LOOP_EXIT);
1354	pFeatures->fVmxRdrandExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_RDRAND_EXIT);
1355	pFeatures->fVmxInvpcid = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_INVPCID);
1356	pFeatures->fVmxVmFunc = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VMFUNC);
1357	pFeatures->fVmxVmcsShadowing = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_VMCS_SHADOWING);
1358	pFeatures->fVmxRdseedExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_RDSEED_EXIT);
1359	pFeatures->fVmxPml = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_PML);
1360	pFeatures->fVmxEptXcptVe = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_EPT_XCPT_VE);
1361	pFeatures->fVmxConcealVmxFromPt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_CONCEAL_VMX_FROM_PT);
1362	pFeatures->fVmxXsavesXrstors = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_XSAVES_XRSTORS);
1363	pFeatures->fVmxPasidTranslate = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_PASID_TRANSLATE);
1364	pFeatures->fVmxModeBasedExecuteEpt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_MODE_BASED_EPT_PERM);
1365	pFeatures->fVmxSppEpt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_SPP_EPT);
1366	pFeatures->fVmxPtEpt = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_PT_EPT);
1367	pFeatures->fVmxUseTscScaling = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_TSC_SCALING);
1368	pFeatures->fVmxUserWaitPause = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_USER_WAIT_PAUSE);
1369	pFeatures->fVmxPconfig = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_PCONFIG);
1370	pFeatures->fVmxEnclvExit = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_ENCLV_EXIT);
1371	pFeatures->fVmxBusLockDetect = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_BUS_LOCK_DETECT);
1372	pFeatures->fVmxInstrTimeout = RT_BOOL(fProcCtls2 & VMX_PROC_CTLS2_INSTR_TIMEOUT);
1373	}
1374
1375	/* Tertiary processor-based VM-execution controls. */
1376	{
1377	uint64_t const fProcCtls3 = pFeatures->fVmxTertiaryExecCtls ? pVmxMsrs->u64ProcCtls3 : 0;
1378	pFeatures->fVmxLoadIwKeyExit = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_LOADIWKEY_EXIT);
1379	pFeatures->fVmxHlat = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_HLAT);
1380	pFeatures->fVmxEptPagingWrite = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_EPT_PAGING_WRITE);
1381	pFeatures->fVmxGstPagingVerify = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_GST_PAGING_VERIFY);
1382	pFeatures->fVmxIpiVirt = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_IPI_VIRT);
1383	pFeatures->fVmxVirtSpecCtrl = RT_BOOL(fProcCtls3 & VMX_PROC_CTLS3_VIRT_SPEC_CTRL);
1384	}
1385
1386	/* VM-exit controls. */
1387	{
1388	uint32_t const fExitCtls = fVmxTrueMsrs ? pVmxMsrs->TrueExitCtls.n.allowed1 : pVmxMsrs->ExitCtls.n.allowed1;
1389	pFeatures->fVmxExitSaveDebugCtls = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_SAVE_DEBUG);
1390	pFeatures->fVmxHostAddrSpaceSize = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_HOST_ADDR_SPACE_SIZE);
1391	pFeatures->fVmxExitAckExtInt = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_ACK_EXT_INT);
1392	pFeatures->fVmxExitSavePatMsr = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_SAVE_PAT_MSR);
1393	pFeatures->fVmxExitLoadPatMsr = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_LOAD_PAT_MSR);
1394	pFeatures->fVmxExitSaveEferMsr = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_SAVE_EFER_MSR);
1395	pFeatures->fVmxExitLoadEferMsr = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_LOAD_EFER_MSR);
1396	pFeatures->fVmxSavePreemptTimer = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_SAVE_PREEMPT_TIMER);
1397	pFeatures->fVmxSecondaryExitCtls = RT_BOOL(fExitCtls & VMX_EXIT_CTLS_USE_SECONDARY_CTLS);
1398	}
1399
1400	/* VM-entry controls. */
1401	{
1402	uint32_t const fEntryCtls = fVmxTrueMsrs ? pVmxMsrs->TrueEntryCtls.n.allowed1 : pVmxMsrs->EntryCtls.n.allowed1;
1403	pFeatures->fVmxEntryLoadDebugCtls = RT_BOOL(fEntryCtls & VMX_ENTRY_CTLS_LOAD_DEBUG);
1404	pFeatures->fVmxIa32eModeGuest = RT_BOOL(fEntryCtls & VMX_ENTRY_CTLS_IA32E_MODE_GUEST);
1405	pFeatures->fVmxEntryLoadEferMsr = RT_BOOL(fEntryCtls & VMX_ENTRY_CTLS_LOAD_EFER_MSR);
1406	pFeatures->fVmxEntryLoadPatMsr = RT_BOOL(fEntryCtls & VMX_ENTRY_CTLS_LOAD_PAT_MSR);
1407	}
1408
1409	/* Miscellaneous data. */
1410	{
1411	uint32_t const fMiscData = pVmxMsrs->u64Misc;
1412	pFeatures->fVmxExitSaveEferLma = RT_BOOL(fMiscData & VMX_MISC_EXIT_SAVE_EFER_LMA);
1413	pFeatures->fVmxPt = RT_BOOL(fMiscData & VMX_MISC_INTEL_PT);
1414	pFeatures->fVmxVmwriteAll = RT_BOOL(fMiscData & VMX_MISC_VMWRITE_ALL);
1415	pFeatures->fVmxEntryInjectSoftInt = RT_BOOL(fMiscData & VMX_MISC_ENTRY_INJECT_SOFT_INT);
1416	}
1417	}
1418
1419
1420	void cpumCpuIdExplodeFeaturesX86SetSummaryBits(CPUMFEATURESX86 *pFeatures)
1421	{
1422	/* Summary or all bits indicating the presence of the IA32_SPEC_CTRL MSR. */
1423	pFeatures->fSpecCtrlMsr = pFeatures->fIbrs
1424	\| pFeatures->fStibp
1425	\| pFeatures->fSsbd
1426	\| pFeatures->fPsfd
1427	\| pFeatures->fIpredCtrl
1428	\| pFeatures->fRrsbaCtrl
1429	\| pFeatures->fDdpdU
1430	\| pFeatures->fBhiCtrl
1431	;
1432	}
1433
1434
1435	int cpumCpuIdExplodeFeaturesX86(PCCPUMCPUIDLEAF paLeaves, uint32_t cLeaves,
1436	struct CPUMMSRS const pMsrs, CPUMFEATURESX86 pFeatures)
1437	{
1438	Assert(pMsrs);
1439	RT_ZERO(*pFeatures);
1440	if (cLeaves >= 2)
1441	{
1442	AssertLogRelReturn(paLeaves[0].uLeaf == 0, VERR_CPUM_IPE_1);
1443	AssertLogRelReturn(paLeaves[1].uLeaf == 1, VERR_CPUM_IPE_1);
1444	PCCPUMCPUIDLEAF const pStd0Leaf = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 0, 0);
1445	AssertLogRelReturn(pStd0Leaf, VERR_CPUM_IPE_1);
1446	PCCPUMCPUIDLEAF const pStd1Leaf = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 1, 0);
1447	AssertLogRelReturn(pStd1Leaf, VERR_CPUM_IPE_1);
1448
1449	pFeatures->enmCpuVendor = CPUMCpuIdDetectX86VendorEx(pStd0Leaf->uEax,
1450	pStd0Leaf->uEbx,
1451	pStd0Leaf->uEcx,
1452	pStd0Leaf->uEdx);
1453	pFeatures->uFamily = RTX86GetCpuFamily(pStd1Leaf->uEax);
1454	pFeatures->uModel = RTX86GetCpuModel(pStd1Leaf->uEax, pFeatures->enmCpuVendor == CPUMCPUVENDOR_INTEL);
1455	pFeatures->uStepping = RTX86GetCpuStepping(pStd1Leaf->uEax);
1456	pFeatures->enmMicroarch = CPUMCpuIdDetermineX86MicroarchEx((CPUMCPUVENDOR)pFeatures->enmCpuVendor,
1457	pFeatures->uFamily,
1458	pFeatures->uModel,
1459	pFeatures->uStepping);
1460
1461	PCCPUMCPUIDLEAF const pExtLeaf8 = cpumCpuIdFindLeaf(paLeaves, cLeaves, 0x80000008);
1462	if (pExtLeaf8)
1463	{
1464	pFeatures->cMaxPhysAddrWidth = pExtLeaf8->uEax & 0xff;
1465	pFeatures->cMaxLinearAddrWidth = (pExtLeaf8->uEax >> 8) & 0xff;
1466	}
1467	else if (pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PSE36)
1468	{
1469	pFeatures->cMaxPhysAddrWidth = 36;
1470	pFeatures->cMaxLinearAddrWidth = 36;
1471	}
1472	else
1473	{
1474	pFeatures->cMaxPhysAddrWidth = 32;
1475	pFeatures->cMaxLinearAddrWidth = 32;
1476	}
1477
1478	/* Standard features. */
1479	pFeatures->fMsr = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_MSR);
1480	pFeatures->fApic = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_APIC);
1481	pFeatures->fX2Apic = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_X2APIC);
1482	pFeatures->fPse = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PSE);
1483	pFeatures->fPse36 = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PSE36);
1484	pFeatures->fPae = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PAE);
1485	pFeatures->fPge = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PGE);
1486	pFeatures->fPat = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_PAT);
1487	pFeatures->fFxSaveRstor = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_FXSR);
1488	pFeatures->fXSaveRstor = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_XSAVE);
1489	pFeatures->fOpSysXSaveRstor = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_OSXSAVE);
1490	pFeatures->fMmx = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_MMX);
1491	pFeatures->fSse = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_SSE);
1492	pFeatures->fSse2 = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_SSE2);
1493	pFeatures->fSse3 = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_SSE3);
1494	pFeatures->fSsse3 = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_SSSE3);
1495	pFeatures->fFma = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_FMA);
1496	pFeatures->fSse41 = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_SSE4_1);
1497	pFeatures->fSse42 = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_SSE4_2);
1498	pFeatures->fAesNi = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_AES);
1499	pFeatures->fAvx = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_AVX);
1500	pFeatures->fTsc = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_TSC);
1501	pFeatures->fSysEnter = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_SEP);
1502	pFeatures->fMtrr = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_MTRR);
1503	pFeatures->fHypervisorPresent = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_HVP);
1504	pFeatures->fMonitorMWait = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_MONITOR);
1505	pFeatures->fCmpXchg8b = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_CX8);
1506	pFeatures->fCmpXchg16b = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_CX16);
1507	pFeatures->fClFlush = RT_BOOL(pStd1Leaf->uEdx & X86_CPUID_FEATURE_EDX_CLFSH);
1508	pFeatures->fPcid = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_PCID);
1509	pFeatures->fPopCnt = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_POPCNT);
1510	pFeatures->fRdRand = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_RDRAND);
1511	pFeatures->fVmx = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_VMX);
1512	pFeatures->fPclMul = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_PCLMUL);
1513	pFeatures->fMovBe = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_MOVBE);
1514	pFeatures->fF16c = RT_BOOL(pStd1Leaf->uEcx & X86_CPUID_FEATURE_ECX_F16C);
1515	# if (defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86)) \
1516	&& !defined(VBOX_VMM_TARGET_ARMV8) /** @todo Ugly hack to avoid dragging in hm_vmx.h when targeting armv8. */
1517	if (pFeatures->fVmx)
1518	cpumExplodeVmxFeatures(&pMsrs->hwvirt.vmx, pFeatures);
1519	# else
1520	RT_NOREF_PV(pMsrs);
1521	# endif
1522
1523	/* Structured extended features. */
1524	PCCPUMCPUIDLEAF const pSxfLeaf0 = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 7, 0);
1525	if (pSxfLeaf0)
1526	{
1527	pFeatures->fFsGsBase = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_FSGSBASE);
1528	pFeatures->fAvx2 = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_AVX2);
1529	pFeatures->fAvx512Foundation = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_AVX512F);
1530	pFeatures->fClFlushOpt = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_CLFLUSHOPT);
1531	pFeatures->fInvpcid = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_INVPCID);
1532	pFeatures->fBmi1 = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_BMI1);
1533	pFeatures->fBmi2 = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_BMI2);
1534	pFeatures->fRdSeed = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_RDSEED);
1535	pFeatures->fHle = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_HLE);
1536	pFeatures->fRtm = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_RTM);
1537	pFeatures->fSha = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_SHA);
1538	pFeatures->fAdx = RT_BOOL(pSxfLeaf0->uEbx & X86_CPUID_STEXT_FEATURE_EBX_ADX);
1539
1540	pFeatures->fIbpb = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_IBRS_IBPB);
1541	pFeatures->fIbrs = pFeatures->fIbpb;
1542	pFeatures->fStibp = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_STIBP);
1543	pFeatures->fSsbd = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_SSBD);
1544	pFeatures->fFlushCmd = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_FLUSH_CMD);
1545	pFeatures->fArchCap = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_ARCHCAP);
1546	pFeatures->fCoreCap = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_CORECAP);
1547	pFeatures->fMdsClear = RT_BOOL(pSxfLeaf0->uEdx & X86_CPUID_STEXT_FEATURE_EDX_MD_CLEAR);
1548	}
1549	PCCPUMCPUIDLEAF const pSxfLeaf2 = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 7, 2);
1550	if (pSxfLeaf2)
1551	{
1552	pFeatures->fPsfd = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_PSFD);
1553	pFeatures->fIpredCtrl = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_IPRED_CTRL);
1554	pFeatures->fRrsbaCtrl = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_RRSBA_CTRL);
1555	pFeatures->fDdpdU = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_DDPD_U);
1556	pFeatures->fBhiCtrl = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_BHI_CTRL);
1557	pFeatures->fMcdtNo = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_MCDT_NO);
1558	pFeatures->fUcLockDis = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_UC_LOCK_DIS);
1559	pFeatures->fMonitorMitgNo = RT_BOOL(pSxfLeaf2->uEdx & X86_CPUID_STEXT_FEATURE_2_EDX_MONITOR_MITG_NO);
1560	}
1561
1562	/* MWAIT/MONITOR leaf. */
1563	PCCPUMCPUIDLEAF const pMWaitLeaf = cpumCpuIdFindLeaf(paLeaves, cLeaves, 5);
1564	if (pMWaitLeaf)
1565	pFeatures->fMWaitExtensions = (pMWaitLeaf->uEcx & (X86_CPUID_MWAIT_ECX_EXT \| X86_CPUID_MWAIT_ECX_BREAKIRQIF0))
1566	== (X86_CPUID_MWAIT_ECX_EXT \| X86_CPUID_MWAIT_ECX_BREAKIRQIF0);
1567
1568	/* Extended features. */
1569	PCCPUMCPUIDLEAF const pExtLeaf = cpumCpuIdFindLeaf(paLeaves, cLeaves, 0x80000001);
1570	if (pExtLeaf)
1571	{
1572	pFeatures->fLongMode = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_EXT_FEATURE_EDX_LONG_MODE);
1573	pFeatures->fSysCall = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_EXT_FEATURE_EDX_SYSCALL);
1574	pFeatures->fNoExecute = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_EXT_FEATURE_EDX_NX);
1575	pFeatures->fLahfSahf = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_EXT_FEATURE_ECX_LAHF_SAHF);
1576	pFeatures->fRdTscP = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_EXT_FEATURE_EDX_RDTSCP);
1577	pFeatures->fMovCr8In32Bit = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_CMPL);
1578	pFeatures->f3DNow = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_3DNOW);
1579	pFeatures->f3DNowPrefetch = (pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_3DNOWPRF)
1580	\|\| (pExtLeaf->uEdx & ( X86_CPUID_EXT_FEATURE_EDX_LONG_MODE
1581	\| X86_CPUID_AMD_FEATURE_EDX_3DNOW));
1582	pFeatures->fAbm = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_ABM);
1583	}
1584
1585	/* VMX (VMXON, VMCS region and related data structures) physical address width (depends on long-mode). */
1586	pFeatures->cVmxMaxPhysAddrWidth = pFeatures->fLongMode ? pFeatures->cMaxPhysAddrWidth : 32;
1587
1588	if ( pExtLeaf
1589	&& ( pFeatures->enmCpuVendor == CPUMCPUVENDOR_AMD
1590	\|\| pFeatures->enmCpuVendor == CPUMCPUVENDOR_HYGON))
1591	{
1592	/* AMD features. */
1593	pFeatures->fMsr \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_MSR);
1594	pFeatures->fApic \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_APIC);
1595	pFeatures->fPse \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_PSE);
1596	pFeatures->fPse36 \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_PSE36);
1597	pFeatures->fPae \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_PAE);
1598	pFeatures->fPge \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_PGE);
1599	pFeatures->fPat \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_PAT);
1600	pFeatures->fFxSaveRstor \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_FXSR);
1601	pFeatures->fMmx \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_MMX);
1602	pFeatures->fTsc \|= RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_TSC);
1603	pFeatures->fAmdMmxExts = RT_BOOL(pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_AXMMX);
1604	pFeatures->fXop = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_XOP);
1605	pFeatures->fTbm = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_TBM);
1606	pFeatures->fSvm = RT_BOOL(pExtLeaf->uEcx & X86_CPUID_AMD_FEATURE_ECX_SVM);
1607
1608	if (pExtLeaf8)
1609	{
1610	pFeatures->fIbpb \|= RT_BOOL(pExtLeaf8->uEbx & X86_CPUID_AMD_EFEID_EBX_IBPB);
1611	pFeatures->fIbrs \|= RT_BOOL(pExtLeaf8->uEbx & X86_CPUID_AMD_EFEID_EBX_IBRS);
1612	pFeatures->fStibp \|= RT_BOOL(pExtLeaf8->uEbx & X86_CPUID_AMD_EFEID_EBX_STIBP);
1613	pFeatures->fSsbd \|= RT_BOOL(pExtLeaf8->uEbx & X86_CPUID_AMD_EFEID_EBX_SPEC_CTRL_SSBD);
1614	pFeatures->fPsfd \|= RT_BOOL(pExtLeaf8->uEbx & X86_CPUID_AMD_EFEID_EBX_PSFD);
1615	}
1616
1617	PCCPUMCPUIDLEAF pExtLeaf21 = cpumCpuIdFindLeaf(paLeaves, cLeaves, 0x80000021);
1618	if (pExtLeaf21)
1619	{
1620	/** @todo IBPB_BRTYPE is implied on Zen 1 & 2.
1621	* https://www.amd.com/content/dam/amd/en/documents/corporate/cr/speculative-return-stack-overflow-whitepaper.pdf */
1622	}
1623
1624	if (pFeatures->fSvm)
1625	{
1626	PCCPUMCPUIDLEAF pSvmLeaf = cpumCpuIdFindLeaf(paLeaves, cLeaves, 0x8000000a);
1627	AssertLogRelReturn(pSvmLeaf, VERR_CPUM_IPE_1);
1628	pFeatures->fSvmNestedPaging = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_NESTED_PAGING);
1629	pFeatures->fSvmLbrVirt = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_LBR_VIRT);
1630	pFeatures->fSvmSvmLock = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_SVM_LOCK);
1631	pFeatures->fSvmNextRipSave = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_NRIP_SAVE);
1632	pFeatures->fSvmTscRateMsr = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_TSC_RATE_MSR);
1633	pFeatures->fSvmVmcbClean = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_VMCB_CLEAN);
1634	pFeatures->fSvmFlusbByAsid = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_FLUSH_BY_ASID);
1635	pFeatures->fSvmDecodeAssists = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_DECODE_ASSISTS);
1636	pFeatures->fSvmPauseFilter = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_PAUSE_FILTER);
1637	pFeatures->fSvmPauseFilterThreshold = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_PAUSE_FILTER_THRESHOLD);
1638	pFeatures->fSvmAvic = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_AVIC);
1639	pFeatures->fSvmVirtVmsaveVmload = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_VIRT_VMSAVE_VMLOAD);
1640	pFeatures->fSvmVGif = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_VGIF);
1641	pFeatures->fSvmGmet = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_GMET);
1642	pFeatures->fSvmX2Avic = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_X2AVIC);
1643	pFeatures->fSvmSSSCheck = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_SSSCHECK);
1644	pFeatures->fSvmSpecCtrl = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_SPEC_CTRL);
1645	pFeatures->fSvmRoGpt = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_ROGPT);
1646	pFeatures->fSvmHostMceOverride = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_HOST_MCE_OVERRIDE);
1647	pFeatures->fSvmTlbiCtl = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_TLBICTL);
1648	pFeatures->fSvmVNmi = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_VNMI);
1649	pFeatures->fSvmIbsVirt = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_IBS_VIRT);
1650	pFeatures->fSvmExtLvtAvicAccessChg = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_EXT_LVT_AVIC_ACCESS_CHG);
1651	pFeatures->fSvmNstVirtVmcbAddrChk = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_NST_VIRT_VMCB_ADDR_CHK);
1652	pFeatures->fSvmBusLockThreshold = RT_BOOL(pSvmLeaf->uEdx & X86_CPUID_SVM_FEATURE_EDX_BUS_LOCK_THRESHOLD);
1653	pFeatures->uSvmMaxAsid = pSvmLeaf->uEbx;
1654	}
1655	}
1656
1657	/*
1658	* Quirks.
1659	*/
1660	pFeatures->fLeakyFxSR = pExtLeaf
1661	&& (pExtLeaf->uEdx & X86_CPUID_AMD_FEATURE_EDX_FFXSR)
1662	&& ( ( pFeatures->enmCpuVendor == CPUMCPUVENDOR_AMD
1663	&& pFeatures->uFamily >= 6 /* K7 and up */)
1664	\|\| pFeatures->enmCpuVendor == CPUMCPUVENDOR_HYGON);
1665
1666	/*
1667	* Max extended (/FPU) state.
1668	*/
1669	pFeatures->cbMaxExtendedState = pFeatures->fFxSaveRstor ? sizeof(X86FXSTATE) : sizeof(X86FPUSTATE);
1670	if (pFeatures->fXSaveRstor)
1671	{
1672	PCCPUMCPUIDLEAF const pXStateLeaf0 = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 13, 0);
1673	if (pXStateLeaf0)
1674	{
1675	if ( pXStateLeaf0->uEcx >= sizeof(X86FXSTATE)
1676	&& pXStateLeaf0->uEcx <= CPUM_MAX_XSAVE_AREA_SIZE
1677	&& RT_ALIGN_32(pXStateLeaf0->uEcx, 8) == pXStateLeaf0->uEcx
1678	&& pXStateLeaf0->uEbx >= sizeof(X86FXSTATE)
1679	&& pXStateLeaf0->uEbx <= pXStateLeaf0->uEcx
1680	&& RT_ALIGN_32(pXStateLeaf0->uEbx, 8) == pXStateLeaf0->uEbx)
1681	{
1682	pFeatures->cbMaxExtendedState = pXStateLeaf0->uEcx;
1683
1684	/* (paranoia:) */
1685	PCCPUMCPUIDLEAF const pXStateLeaf1 = cpumCpuIdFindLeafEx(paLeaves, cLeaves, 13, 1);
1686	if ( pXStateLeaf1
1687	&& pXStateLeaf1->uEbx > pFeatures->cbMaxExtendedState
1688	&& pXStateLeaf1->uEbx <= CPUM_MAX_XSAVE_AREA_SIZE
1689	&& (pXStateLeaf1->uEcx \|\| pXStateLeaf1->uEdx) )
1690	pFeatures->cbMaxExtendedState = pXStateLeaf1->uEbx;
1691	}
1692	else
1693	AssertLogRelMsgFailedStmt(("Unexpected max/cur XSAVE area sizes: %#x/%#x\n", pXStateLeaf0->uEcx, pXStateLeaf0->uEbx),
1694	pFeatures->fXSaveRstor = 0);
1695	}
1696	else
1697	AssertLogRelMsgFailedStmt(("Expected leaf eax=0xd/ecx=0 with the XSAVE/XRSTOR feature!\n"),
1698	pFeatures->fXSaveRstor = 0);
1699	}
1700
1701	/*
1702	* Enable or disable VEX support depending on whether it's needed. Note that AVX,
1703	* BMI1, and BMI2 all use VEX encoding but are theoretically independent of each other.
1704	*/
1705	pFeatures->fVex = pFeatures->fAvx \| pFeatures->fBmi1 \| pFeatures->fBmi2;
1706	}
1707	else
1708	AssertLogRelReturn(cLeaves == 0, VERR_CPUM_IPE_1);
1709
1710	cpumCpuIdExplodeFeaturesX86SetSummaryBits(pFeatures);
1711	return VINF_SUCCESS;
1712	}
1713
1714
1715	/**
1716	* Helper for extracting feature bits from IA32_ARCH_CAPABILITIES.
1717	*/
1718	void cpumCpuIdExplodeArchCapabilities(CPUMFEATURESX86 *pFeatures, bool fHasArchCap, uint64_t fArchVal)
1719	{
1720	Assert(fHasArchCap \|\| fArchVal == 0);
1721	pFeatures->fArchCap = fHasArchCap;
1722	pFeatures->fArchRdclNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_RDCL_NO);
1723	pFeatures->fArchIbrsAll = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_IBRS_ALL);
1724	pFeatures->fArchRsbOverride = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_RSBO);
1725	pFeatures->fArchVmmNeedNotFlushL1d = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_VMM_NEED_NOT_FLUSH_L1D);
1726	pFeatures->fArchSsbNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_SSB_NO);
1727	pFeatures->fArchMdsNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_MDS_NO);
1728	pFeatures->fArchIfPschangeMscNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_IF_PSCHANGE_MC_NO);
1729	pFeatures->fArchTsxCtrl = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_TSX_CTRL);
1730	pFeatures->fArchTaaNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_TAA_NO);
1731	pFeatures->fArchMiscPackageCtrls = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_MISC_PACKAGE_CTRLS);
1732	pFeatures->fArchEnergyFilteringCtl = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_ENERGY_FILTERING_CTL);
1733	pFeatures->fArchDoitm = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_DOITM);
1734	pFeatures->fArchSbdrSsdpNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_SBDR_SSDP_NO);
1735	pFeatures->fArchFbsdpNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_FBSDP_NO);
1736	pFeatures->fArchPsdpNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_PSDP_NO);
1737	pFeatures->fArchFbClear = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_FB_CLEAR);
1738	pFeatures->fArchFbClearCtrl = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_FB_CLEAR_CTRL);
1739	pFeatures->fArchRrsba = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_RRSBA);
1740	pFeatures->fArchBhiNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_BHI_NO);
1741	pFeatures->fArchXapicDisableStatus = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_XAPIC_DISABLE_STATUS);
1742	pFeatures->fArchOverclockingStatus = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_OVERCLOCKING_STATUS);
1743	pFeatures->fArchPbrsbNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_PBRSB_NO);
1744	pFeatures->fArchGdsCtrl = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_GDS_CTRL);
1745	pFeatures->fArchGdsNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_GDS_NO);
1746	pFeatures->fArchRfdsNo = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_RFDS_NO);
1747	pFeatures->fArchRfdsClear = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_RFDS_CLEAR);
1748	pFeatures->fArchIgnUmonitorSupport = RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_IGN_UMONITOR_SUPPORT);
1749	pFeatures->fArchMonUmonMitigSupport= RT_BOOL(fArchVal & MSR_IA32_ARCH_CAP_F_MON_UMON_MITIG_SUPPORT);
1750	}
1751
1752
1753	# if defined(VBOX_VMM_TARGET_X86) \|\| defined(VBOX_VMM_TARGET_AGNOSTIC)
1754	/**
1755	* Sets the guest IA32_ARCH_CAPABILITIES value and associated feature bits.
1756	*/
1757	void cpumCpuIdSetGuestArchCapabilities(PVMCC pVM, bool fHasArchCap, uint64_t fArchVal, bool fHasIbrs)
1758	{
1759	if (!fHasArchCap)
1760	fArchVal = 0;
1761	else if (!fHasIbrs)
1762	fArchVal &= ~MSR_IA32_ARCH_CAP_F_IBRS_ALL;
1763	fArchVal &= ~( RT_BIT_64(9)
1764	\| MSR_IA32_ARCH_CAP_F_MISC_PACKAGE_CTRLS
1765	\| MSR_IA32_ARCH_CAP_F_ENERGY_FILTERING_CTL
1766	\| MSR_IA32_ARCH_CAP_F_DOITM
1767	\| RT_BIT_64(16)
1768	\| RT_BIT_64(22)
1769	\| MSR_IA32_ARCH_CAP_F_FB_CLEAR_CTRL
1770	/** @todo mask off MSR_IA32_ARCH_CAP_F_RRSBA ? */
1771	\| MSR_IA32_ARCH_CAP_F_XAPIC_DISABLE_STATUS
1772	\| MSR_IA32_ARCH_CAP_F_OVERCLOCKING_STATUS /** @todo expose IA32_OVERCLOCKING_STATUS */
1773	\| MSR_IA32_ARCH_CAP_F_GDS_CTRL
1774	\| MSR_IA32_ARCH_CAP_F_IGN_UMONITOR_SUPPORT
1775	\| MSR_IA32_ARCH_CAP_F_MON_UMON_MITIG_SUPPORT
1776	\| ~(RT_BIT_64(31) - 1U)
1777	);
1778	VMCC_FOR_EACH_VMCPU_STMT(pVM, pVCpu->cpum.s.GuestMsrs.msr.ArchCaps = fArchVal);
1779
1780	cpumCpuIdExplodeArchCapabilities(&pVM->cpum.s.GuestFeatures, fHasArchCap, fArchVal);
1781	LogRel(("CPUM: Guest IA32_ARCH_CAPABILITIES = %#RX64\n", fArchVal));
1782	}
1783	# endif
1784
1785
1786	# if defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64)
1787	/**
1788	* Sets host & guest feature bits & MSRs related to IA32_ARCH_CAPABILITIES.
1789	*
1790	* ASSUMES this is called after the basic guest features has been exploded.
1791	*/
1792	VMM_INT_DECL(void) CPUMCpuIdApplyX86HostArchCapabilities(PVMCC pVM, bool fHasArchCap, uint64_t fHostArchVal)
1793	{
1794	cpumCpuIdExplodeArchCapabilities(const_cast<CPUMFEATURESX86 *>(&pVM->cpum.s.HostFeatures.s), fHasArchCap, fHostArchVal);
1795	LogRel(("CPUM: Host IA32_ARCH_CAPABILITIES = %#RX64\n", fHostArchVal));
1796
1797	# if defined(VBOX_VMM_TARGET_X86) \|\| defined(VBOX_VMM_TARGET_AGNOSTIC)
1798	# ifdef VBOX_VMM_TARGET_AGNOSTIC
1799	/** @todo arm on x86: check VM target. */
1800	# endif
1801	cpumCpuIdSetGuestArchCapabilities(pVM, fHasArchCap && pVM->cpum.s.GuestFeatures.fArchCap,
1802	fHostArchVal, pVM->cpum.s.GuestFeatures.fIbrs);
1803	# endif
1804	}
1805	# endif /* defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) */
1806
1807	#endif /* defined(RT_ARCH_X86) \|\| defined(RT_ARCH_AMD64) \|\| defined(VBOX_VMM_TARGET_X86) */
1808
1809	#if defined(RT_ARCH_ARM64)
1810	/**
1811	* Collects the ID registers from an ARMv8 host.
1812	*
1813	* This isn't trivial an all hosts when running in userland and there is no
1814	* support driver handy.
1815	*/
1816	VMMDECL(int) CPUMCpuIdCollectIdRegistersFromArmV8Host(PCPUMARMV8IDREGS pIdRegs)
1817	{
1818	# ifdef _MSC_VER
1819	# define READ_SYS_REG(a_u64Dst, a_SysRegName) do { \
1820	(a_u64Dst) = (uint64_t)_ReadStatusReg(RT_CONCAT(ARMV8_AARCH64_SYSREG_,a_SysRegName) & 0x7fff); \
1821	} while (0)
1822	# else
1823	# define READ_SYS_REG(a_u64Dst, a_SysRegName) do { \
1824	__asm__ __volatile__ ("mrs %0, " #a_SysRegName : "=r" (a_u64Dst)); \
1825	} while (0)
1826	# endif
1827
1828	RT_ZERO(*pIdRegs);
1829
1830	/*
1831	* CTR_EL0 can be trapped when executed in L0 (SCTLR_EL0.UCT) and macOS
1832	* & Windows does so by default. Linux OTOH typically exposes all the
1833	* feature registers to user land with some sanitizing.
1834	*/
1835	# if !defined(IN_RING3) \|\| defined(RT_OS_LINUX)
1836	READ_SYS_REG(pIdRegs->u64RegCtrEl0, CTR_EL0);
1837	# endif
1838	READ_SYS_REG(pIdRegs->u64RegDczidEl0, DCZID_EL0);
1839
1840	# if defined(IN_RING0) \|\| defined(RT_OS_LINUX)
1841	# ifdef IN_RING3
1842	if (getauxval(AT_HWCAP) & HWCAP_CPUID)
1843	# endif
1844	{
1845	READ_SYS_REG(pIdRegs->u64RegIdAa64Pfr0El1, ID_AA64PFR0_EL1);
1846	READ_SYS_REG(pIdRegs->u64RegIdAa64Pfr1El1, ID_AA64PFR1_EL1);
1847	READ_SYS_REG(pIdRegs->u64RegIdAa64Dfr0El1, ID_AA64DFR0_EL1);
1848	READ_SYS_REG(pIdRegs->u64RegIdAa64Dfr1El1, ID_AA64DFR1_EL1);
1849	/// @todo READ_SYS_REG(pIdRegs->u64RegIdAa64Dfr2El1, ID_AA64DFR2_EL1);
1850	READ_SYS_REG(pIdRegs->u64RegIdAa64Afr0El1, ID_AA64AFR0_EL1);
1851	READ_SYS_REG(pIdRegs->u64RegIdAa64Afr1El1, ID_AA64AFR1_EL1);
1852	READ_SYS_REG(pIdRegs->u64RegIdAa64Isar0El1, ID_AA64ISAR0_EL1);
1853	READ_SYS_REG(pIdRegs->u64RegIdAa64Isar1El1, ID_AA64ISAR1_EL1);
1854	READ_SYS_REG(pIdRegs->u64RegIdAa64Isar2El1, ID_AA64ISAR2_EL1);
1855	/// @todo READ_SYS_REG(pIdRegs->u64RegIdAa64Isar3El1, ID_AA64ISAR3_EL1);
1856	READ_SYS_REG(pIdRegs->u64RegIdAa64Mmfr0El1, ID_AA64MMFR0_EL1);
1857	READ_SYS_REG(pIdRegs->u64RegIdAa64Mmfr1El1, ID_AA64MMFR1_EL1);
1858	READ_SYS_REG(pIdRegs->u64RegIdAa64Mmfr2El1, ID_AA64MMFR2_EL1);
1859	/// @todo READ_SYS_REG(pIdRegs->u64RegIdAa64Mmfr3El1, ID_AA64MMFR3_EL1);
1860	/// @todo READ_SYS_REG(pIdRegs->u64RegIdAa64Mmfr4El1, ID_AA64MMFR4_EL1);
1861	# ifndef RT_OS_LINUX /* Not supported */
1862	READ_SYS_REG(pIdRegs->u64RegClidrEl1, CLIDR_EL1);
1863	# endif
1864
1865	/// @todo READ_SYS_REG(pIdRegs->uMainIdRegEl1, MIDR_EL1);
1866	/// @todo READ_SYS_REG(pIdRegs->uMpIdRegEl1, MPIDR_EL1);
1867	/// @todo READ_SYS_REG(pIdRegs->uRevIdRegEl1, REVIDR_EL1);
1868	return VINF_SUCCESS;
1869	}
1870	# endif
1871	# ifndef IN_RING0
1872	/** @todo On darwin we should just cache the information (CPU DB) and figure
1873	* out which Apple Mx we're running on. */
1874	/** @todo Make the info available via the support driver... */
1875	return VINF_SUCCESS;
1876	# endif
1877	}
1878	#endif /* defined(RT_ARCH_ARM64) */
1879
1880	#if defined(RT_ARCH_ARM64) \|\| defined(VBOX_VMM_TARGET_ARMV8)
1881	/**
1882	* Explode the CPU features from the given ID registers.
1883	*
1884	* @returns VBox status code.
1885	* @param pIdRegs The ID registers to explode the features from.
1886	* @param pFeatures Where to store the features to.
1887	*/
1888	int cpumCpuIdExplodeFeaturesArmV8(PCCPUMARMV8IDREGS pIdRegs, CPUMFEATURESARMV8 *pFeatures)
1889	{
1890	uint64_t u64IdReg = pIdRegs->u64RegIdAa64Mmfr0El1;
1891
1892	static uint8_t s_aPaRange[] = { 32, 36, 40, 42, 44, 48, 52 };
1893	AssertLogRelMsgReturn(RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_PARANGE) < RT_ELEMENTS(s_aPaRange),
1894	("CPUM: Invalid/Unsupported PARange value in ID_AA64MMFR0_EL1 register: %u\n",
1895	RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_PARANGE)),
1896	VERR_CPUM_IPE_1);
1897
1898	pFeatures->cMaxPhysAddrWidth = s_aPaRange[RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_PARANGE)];
1899	pFeatures->fTGran4K = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_TGRAN4) != ARMV8_ID_AA64MMFR0_EL1_TGRAN4_NOT_IMPL;
1900	pFeatures->fTGran16K = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_TGRAN16) != ARMV8_ID_AA64MMFR0_EL1_TGRAN16_NOT_IMPL;
1901	pFeatures->fTGran64K = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_TGRAN64) != ARMV8_ID_AA64MMFR0_EL1_TGRAN64_NOT_IMPL;
1902
1903	/* ID_AA64ISAR0_EL1 features. */
1904	u64IdReg = pIdRegs->u64RegIdAa64Isar0El1;
1905	pFeatures->fAes = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_AES) >= ARMV8_ID_AA64ISAR0_EL1_AES_SUPPORTED;
1906	pFeatures->fPmull = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_AES) >= ARMV8_ID_AA64ISAR0_EL1_AES_SUPPORTED_PMULL;
1907	pFeatures->fSha1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SHA1) >= ARMV8_ID_AA64ISAR0_EL1_SHA1_SUPPORTED;
1908	pFeatures->fSha256 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SHA2) >= ARMV8_ID_AA64ISAR0_EL1_SHA2_SUPPORTED_SHA256;
1909	pFeatures->fSha512 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SHA2) >= ARMV8_ID_AA64ISAR0_EL1_SHA2_SUPPORTED_SHA256_SHA512;
1910	pFeatures->fCrc32 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_CRC32) >= ARMV8_ID_AA64ISAR0_EL1_CRC32_SUPPORTED;
1911	pFeatures->fLse = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_ATOMIC) >= ARMV8_ID_AA64ISAR0_EL1_ATOMIC_SUPPORTED;
1912	pFeatures->fTme = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_TME) >= ARMV8_ID_AA64ISAR0_EL1_TME_SUPPORTED;
1913	pFeatures->fRdm = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_RDM) >= ARMV8_ID_AA64ISAR0_EL1_RDM_SUPPORTED;
1914	pFeatures->fSha3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SHA3) >= ARMV8_ID_AA64ISAR0_EL1_SHA3_SUPPORTED;
1915	pFeatures->fSm3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SM3) >= ARMV8_ID_AA64ISAR0_EL1_SM3_SUPPORTED;
1916	pFeatures->fSm4 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_SM4) >= ARMV8_ID_AA64ISAR0_EL1_SM4_SUPPORTED;
1917	pFeatures->fDotProd = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_DP) >= ARMV8_ID_AA64ISAR0_EL1_DP_SUPPORTED;
1918	pFeatures->fFhm = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_FHM) >= ARMV8_ID_AA64ISAR0_EL1_FHM_SUPPORTED;
1919	pFeatures->fFlagM = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_TS) >= ARMV8_ID_AA64ISAR0_EL1_TS_SUPPORTED;
1920	pFeatures->fFlagM2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_TS) >= ARMV8_ID_AA64ISAR0_EL1_TS_SUPPORTED_2;
1921	pFeatures->fTlbios = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_TLB) >= ARMV8_ID_AA64ISAR0_EL1_TLB_SUPPORTED;
1922	pFeatures->fTlbirange = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_TLB) >= ARMV8_ID_AA64ISAR0_EL1_TLB_SUPPORTED_RANGE;
1923	pFeatures->fRng = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR0_EL1_RNDR) >= ARMV8_ID_AA64ISAR0_EL1_RNDR_SUPPORTED;
1924
1925	/* ID_AA64ISAR1_EL1 features. */
1926	u64IdReg = pIdRegs->u64RegIdAa64Isar1El1;
1927	pFeatures->fDpb = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_DPB) >= ARMV8_ID_AA64ISAR1_EL1_DPB_SUPPORTED;
1928	pFeatures->fDpb2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_DPB) >= ARMV8_ID_AA64ISAR1_EL1_DPB_SUPPORTED_2;
1929
1930	/* PAuth using QARMA5. */
1931	pFeatures->fPacQarma5 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) != ARMV8_ID_AA64ISAR1_EL1_APA_NOT_IMPL;
1932	if (pFeatures->fPacQarma5)
1933	{
1934	pFeatures->fPAuth = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) >= ARMV8_ID_AA64ISAR1_EL1_APA_SUPPORTED_PAUTH;
1935	pFeatures->fEpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) >= ARMV8_ID_AA64ISAR1_EL1_APA_SUPPORTED_EPAC;
1936	pFeatures->fPAuth2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) >= ARMV8_ID_AA64ISAR1_EL1_APA_SUPPORTED_PAUTH2;
1937	pFeatures->fFpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) >= ARMV8_ID_AA64ISAR1_EL1_APA_SUPPORTED_FPAC;
1938	pFeatures->fFpacCombine = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_APA) >= ARMV8_ID_AA64ISAR1_EL1_APA_SUPPORTED_FPACCOMBINE;
1939	}
1940
1941	/* PAuth using implementation defined algorithm. */
1942	pFeatures->fPacImp = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) != ARMV8_ID_AA64ISAR1_EL1_API_NOT_IMPL;
1943	if (pFeatures->fPacQarma5)
1944	{
1945	pFeatures->fPAuth = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) >= ARMV8_ID_AA64ISAR1_EL1_API_SUPPORTED_PAUTH;
1946	pFeatures->fEpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) >= ARMV8_ID_AA64ISAR1_EL1_API_SUPPORTED_EPAC;
1947	pFeatures->fPAuth2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) >= ARMV8_ID_AA64ISAR1_EL1_API_SUPPORTED_PAUTH2;
1948	pFeatures->fFpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) >= ARMV8_ID_AA64ISAR1_EL1_API_SUPPORTED_FPAC;
1949	pFeatures->fFpacCombine = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_API) >= ARMV8_ID_AA64ISAR1_EL1_API_SUPPORTED_FPACCOMBINE;
1950	}
1951
1952	pFeatures->fJscvt = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_FJCVTZS) >= ARMV8_ID_AA64ISAR1_EL1_FJCVTZS_SUPPORTED;
1953	pFeatures->fFcma = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_FCMA) >= ARMV8_ID_AA64ISAR1_EL1_FCMA_SUPPORTED;
1954	pFeatures->fLrcpc = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_LRCPC) >= ARMV8_ID_AA64ISAR1_EL1_LRCPC_SUPPORTED;
1955	pFeatures->fLrcpc2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_LRCPC) >= ARMV8_ID_AA64ISAR1_EL1_LRCPC_SUPPORTED_2;
1956	pFeatures->fFrintts = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_FRINTTS) >= ARMV8_ID_AA64ISAR1_EL1_FRINTTS_SUPPORTED;
1957	pFeatures->fSb = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_SB) >= ARMV8_ID_AA64ISAR1_EL1_SB_SUPPORTED;
1958	pFeatures->fSpecres = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_SPECRES) >= ARMV8_ID_AA64ISAR1_EL1_SPECRES_SUPPORTED;
1959	pFeatures->fBf16 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_BF16) >= ARMV8_ID_AA64ISAR1_EL1_BF16_SUPPORTED_BF16;
1960	pFeatures->fEbf16 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_BF16) >= ARMV8_ID_AA64ISAR1_EL1_BF16_SUPPORTED_EBF16;
1961	pFeatures->fDgh = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_DGH) >= ARMV8_ID_AA64ISAR1_EL1_DGH_SUPPORTED;
1962	pFeatures->fI8mm = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_I8MM) >= ARMV8_ID_AA64ISAR1_EL1_I8MM_SUPPORTED;
1963	pFeatures->fXs = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_XS) >= ARMV8_ID_AA64ISAR1_EL1_XS_SUPPORTED;
1964	pFeatures->fLs64 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_LS64) >= ARMV8_ID_AA64ISAR1_EL1_LS64_SUPPORTED;
1965	pFeatures->fLs64V = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_LS64) >= ARMV8_ID_AA64ISAR1_EL1_LS64_SUPPORTED_V;
1966	pFeatures->fLs64Accdata = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR1_EL1_LS64) >= ARMV8_ID_AA64ISAR1_EL1_LS64_SUPPORTED_ACCDATA;
1967
1968	/* ID_AA64ISAR2_EL1 features. */
1969	u64IdReg = pIdRegs->u64RegIdAa64Isar2El1;
1970	pFeatures->fWfxt = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_WFXT) >= ARMV8_ID_AA64ISAR2_EL1_WFXT_SUPPORTED;
1971	pFeatures->fRpres = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_RPRES) >= ARMV8_ID_AA64ISAR2_EL1_RPRES_SUPPORTED;
1972
1973	/* PAuth using QARMA3. */
1974	pFeatures->fPacQarma3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_GPA3) >= ARMV8_ID_AA64ISAR2_EL1_GPA3_SUPPORTED;
1975	pFeatures->fPacQarma3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) != ARMV8_ID_AA64ISAR2_EL1_APA3_NOT_IMPL;
1976	if (pFeatures->fPacQarma5)
1977	{
1978	pFeatures->fPAuth = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) >= ARMV8_ID_AA64ISAR2_EL1_APA3_SUPPORTED_PAUTH;
1979	pFeatures->fEpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) >= ARMV8_ID_AA64ISAR2_EL1_APA3_SUPPORTED_EPAC;
1980	pFeatures->fPAuth2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) >= ARMV8_ID_AA64ISAR2_EL1_APA3_SUPPORTED_PAUTH2;
1981	pFeatures->fFpac = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) >= ARMV8_ID_AA64ISAR2_EL1_APA3_SUPPORTED_FPAC;
1982	pFeatures->fFpacCombine = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_APA3) >= ARMV8_ID_AA64ISAR2_EL1_APA3_SUPPORTED_FPACCOMBINE;
1983	}
1984
1985	pFeatures->fMops = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_MOPS) >= ARMV8_ID_AA64ISAR2_EL1_MOPS_SUPPORTED;
1986	pFeatures->fHbc = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_BC) >= ARMV8_ID_AA64ISAR2_EL1_BC_SUPPORTED;
1987	pFeatures->fConstPacField = RT_BF_GET(u64IdReg, ARMV8_ID_AA64ISAR2_EL1_PACFRAC) >= ARMV8_ID_AA64ISAR2_EL1_PACFRAC_TRUE;
1988
1989	/* ID_AA64PFR0_EL1 */
1990	u64IdReg = pIdRegs->u64RegIdAa64Pfr0El1;
1991	/* The FP and AdvSIMD field must have the same value. */
1992	Assert(RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_FP) == RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_ADVSIMD));
1993	pFeatures->fFp = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_FP) != ARMV8_ID_AA64PFR0_EL1_FP_NOT_IMPL;
1994	pFeatures->fFp16 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_FP) == ARMV8_ID_AA64PFR0_EL1_FP_IMPL_SP_DP_HP;
1995	pFeatures->fAdvSimd = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_ADVSIMD) != ARMV8_ID_AA64PFR0_EL1_ADVSIMD_NOT_IMPL;
1996	pFeatures->fFp16 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_ADVSIMD) == ARMV8_ID_AA64PFR0_EL1_ADVSIMD_IMPL_SP_DP_HP;
1997	pFeatures->fRas = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_RAS) >= ARMV8_ID_AA64PFR0_EL1_RAS_SUPPORTED;
1998	pFeatures->fRasV1p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_RAS) >= ARMV8_ID_AA64PFR0_EL1_RAS_V1P1;
1999	pFeatures->fSve = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_SVE) >= ARMV8_ID_AA64PFR0_EL1_SVE_SUPPORTED;
2000	pFeatures->fSecEl2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_SEL2) >= ARMV8_ID_AA64PFR0_EL1_SEL2_SUPPORTED;
2001	pFeatures->fAmuV1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_AMU) >= ARMV8_ID_AA64PFR0_EL1_AMU_V1;
2002	pFeatures->fAmuV1p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_AMU) >= ARMV8_ID_AA64PFR0_EL1_AMU_V1P1;
2003	pFeatures->fDit = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_DIT) >= ARMV8_ID_AA64PFR0_EL1_DIT_SUPPORTED;
2004	pFeatures->fRme = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_RME) >= ARMV8_ID_AA64PFR0_EL1_RME_SUPPORTED;
2005	pFeatures->fCsv2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_CSV2) >= ARMV8_ID_AA64PFR0_EL1_CSV2_SUPPORTED;
2006	pFeatures->fCsv2v3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR0_EL1_CSV2) >= ARMV8_ID_AA64PFR0_EL1_CSV2_3_SUPPORTED;
2007
2008	/* ID_AA64PFR1_EL1 */
2009	u64IdReg = pIdRegs->u64RegIdAa64Pfr1El1;
2010	pFeatures->fBti = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_BT) >= ARMV8_ID_AA64PFR1_EL1_BT_SUPPORTED;
2011	pFeatures->fSsbs = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_SSBS) >= ARMV8_ID_AA64PFR1_EL1_SSBS_SUPPORTED;
2012	pFeatures->fSsbs2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_SSBS) >= ARMV8_ID_AA64PFR1_EL1_SSBS_SUPPORTED_MSR_MRS;
2013	pFeatures->fMte = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_MTE) >= ARMV8_ID_AA64PFR1_EL1_MTE_INSN_ONLY;
2014	pFeatures->fMte2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_MTE) >= ARMV8_ID_AA64PFR1_EL1_MTE_FULL;
2015	pFeatures->fMte3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_MTE) >= ARMV8_ID_AA64PFR1_EL1_MTE_FULL_ASYM_TAG_FAULT_CHK;
2016	/** @todo RAS_frac, MPAM_frac, CSV2_frac. */
2017	pFeatures->fSme = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_SME) >= ARMV8_ID_AA64PFR1_EL1_SME_SUPPORTED;
2018	pFeatures->fSme2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_SME) >= ARMV8_ID_AA64PFR1_EL1_SME_SME2;
2019	pFeatures->fRngTrap = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_RNDRTRAP) >= ARMV8_ID_AA64PFR1_EL1_RNDRTRAP_SUPPORTED;
2020	pFeatures->fNmi = RT_BF_GET(u64IdReg, ARMV8_ID_AA64PFR1_EL1_NMI) >= ARMV8_ID_AA64PFR1_EL1_NMI_SUPPORTED;
2021
2022	/* ID_AA64MMFR0_EL1 */
2023	u64IdReg = pIdRegs->u64RegIdAa64Mmfr0El1;
2024	pFeatures->fExs = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_EXS) >= ARMV8_ID_AA64MMFR0_EL1_EXS_SUPPORTED;
2025	pFeatures->fFgt = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_FGT) >= ARMV8_ID_AA64MMFR0_EL1_FGT_SUPPORTED;
2026	pFeatures->fEcv = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR0_EL1_ECV) >= ARMV8_ID_AA64MMFR0_EL1_ECV_SUPPORTED;
2027
2028	/* ID_AA64MMFR1_EL1 */
2029	u64IdReg = pIdRegs->u64RegIdAa64Mmfr1El1;
2030	pFeatures->fHafdbs = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_HAFDBS) >= ARMV8_ID_AA64MMFR1_EL1_HAFDBS_SUPPORTED;
2031	pFeatures->fVmid16 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_VMIDBITS) >= ARMV8_ID_AA64MMFR1_EL1_VMIDBITS_16;
2032	pFeatures->fVhe = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_VHE) >= ARMV8_ID_AA64MMFR1_EL1_VHE_SUPPORTED;
2033	pFeatures->fHpds = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_HPDS) >= ARMV8_ID_AA64MMFR1_EL1_HPDS_SUPPORTED;
2034	pFeatures->fHpds2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_HPDS) >= ARMV8_ID_AA64MMFR1_EL1_HPDS_SUPPORTED_2;
2035	pFeatures->fLor = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_LO) >= ARMV8_ID_AA64MMFR1_EL1_LO_SUPPORTED;
2036	pFeatures->fPan = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_PAN) >= ARMV8_ID_AA64MMFR1_EL1_PAN_SUPPORTED;
2037	pFeatures->fPan2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_PAN) >= ARMV8_ID_AA64MMFR1_EL1_PAN_SUPPORTED_2;
2038	pFeatures->fPan3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_PAN) >= ARMV8_ID_AA64MMFR1_EL1_PAN_SUPPORTED_3;
2039	pFeatures->fXnx = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_XNX) >= ARMV8_ID_AA64MMFR1_EL1_XNX_SUPPORTED;
2040	pFeatures->fTwed = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_TWED) >= ARMV8_ID_AA64MMFR1_EL1_TWED_SUPPORTED;
2041	pFeatures->fEts2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_ETS) >= ARMV8_ID_AA64MMFR1_EL1_ETS_SUPPORTED;
2042	pFeatures->fHcx = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_HCX) >= ARMV8_ID_AA64MMFR1_EL1_HCX_SUPPORTED;
2043	pFeatures->fAfp = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_AFP) >= ARMV8_ID_AA64MMFR1_EL1_AFP_SUPPORTED;
2044	pFeatures->fNTlbpa = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_NTLBPA) >= ARMV8_ID_AA64MMFR1_EL1_NTLBPA_INCLUDE_COHERENT_ONLY;
2045	pFeatures->fTidcp1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_TIDCP1) >= ARMV8_ID_AA64MMFR1_EL1_TIDCP1_SUPPORTED;
2046	pFeatures->fCmow = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR1_EL1_CMOW) >= ARMV8_ID_AA64MMFR1_EL1_CMOW_SUPPORTED;
2047
2048	/* ID_AA64MMFR2_EL1 */
2049	u64IdReg = pIdRegs->u64RegIdAa64Mmfr2El1;
2050	pFeatures->fTtcnp = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_CNP) >= ARMV8_ID_AA64MMFR2_EL1_CNP_SUPPORTED;
2051	pFeatures->fUao = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_UAO) >= ARMV8_ID_AA64MMFR2_EL1_UAO_SUPPORTED;
2052	pFeatures->fLsmaoc = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_LSM) >= ARMV8_ID_AA64MMFR2_EL1_LSM_SUPPORTED;
2053	pFeatures->fIesb = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_IESB) >= ARMV8_ID_AA64MMFR2_EL1_IESB_SUPPORTED;
2054	pFeatures->fLva = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_VARANGE) >= ARMV8_ID_AA64MMFR2_EL1_VARANGE_52BITS_64KB_GRAN;
2055	pFeatures->fCcidx = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_CCIDX) >= ARMV8_ID_AA64MMFR2_EL1_CCIDX_64BIT;
2056	pFeatures->fNv = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_NV) >= ARMV8_ID_AA64MMFR2_EL1_NV_SUPPORTED;
2057	pFeatures->fNv2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_NV) >= ARMV8_ID_AA64MMFR2_EL1_NV_SUPPORTED_2;
2058	pFeatures->fTtst = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_ST) >= ARMV8_ID_AA64MMFR2_EL1_ST_SUPPORTED;
2059	pFeatures->fLse2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_AT) >= ARMV8_ID_AA64MMFR2_EL1_AT_SUPPORTED;
2060	pFeatures->fIdst = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_IDS) >= ARMV8_ID_AA64MMFR2_EL1_IDS_EC_18H;
2061	pFeatures->fS2Fwb = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_FWB) >= ARMV8_ID_AA64MMFR2_EL1_FWB_SUPPORTED;
2062	pFeatures->fTtl = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_TTL) >= ARMV8_ID_AA64MMFR2_EL1_TTL_SUPPORTED;
2063	pFeatures->fEvt = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_EVT) >= ARMV8_ID_AA64MMFR2_EL1_EVT_SUPPORTED;
2064	pFeatures->fE0Pd = RT_BF_GET(u64IdReg, ARMV8_ID_AA64MMFR2_EL1_E0PD) >= ARMV8_ID_AA64MMFR2_EL1_E0PD_SUPPORTED;
2065
2066	/* ID_AA64DFR0_EL1 */
2067	u64IdReg = pIdRegs->u64RegIdAa64Dfr0El1;
2068	pFeatures->fDebugV8p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_DEBUGVER) >= ARMV8_ID_AA64DFR0_EL1_DEBUGVER_ARMV8_VHE;
2069	pFeatures->fDebugV8p2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_DEBUGVER) >= ARMV8_ID_AA64DFR0_EL1_DEBUGVER_ARMV8p2;
2070	pFeatures->fDebugV8p4 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_DEBUGVER) >= ARMV8_ID_AA64DFR0_EL1_DEBUGVER_ARMV8p4;
2071	pFeatures->fDebugV8p8 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_DEBUGVER) >= ARMV8_ID_AA64DFR0_EL1_DEBUGVER_ARMV8p8;
2072	pFeatures->fPmuV3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3;
2073	pFeatures->fPmuV3p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3P1;
2074	pFeatures->fPmuV3p4 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3P4;
2075	pFeatures->fPmuV3p5 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3P5;
2076	pFeatures->fPmuV3p7 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3P7;
2077	pFeatures->fPmuV3p8 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMUVER) >= ARMV8_ID_AA64DFR0_EL1_PMUVER_SUPPORTED_V3P8;
2078	pFeatures->fSpe = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMSVER) >= ARMV8_ID_AA64DFR0_EL1_PMSVER_SUPPORTED;
2079	pFeatures->fSpeV1p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMSVER) >= ARMV8_ID_AA64DFR0_EL1_PMSVER_SUPPORTED_V1P1;
2080	pFeatures->fSpeV1p2 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMSVER) >= ARMV8_ID_AA64DFR0_EL1_PMSVER_SUPPORTED_V1P2;
2081	pFeatures->fSpeV1p3 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_PMSVER) >= ARMV8_ID_AA64DFR0_EL1_PMSVER_SUPPORTED_V1P3;
2082	pFeatures->fDoubleLock = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_DOUBLELOCK) == ARMV8_ID_AA64DFR0_EL1_DOUBLELOCK_SUPPORTED;
2083	pFeatures->fTrf = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_TRACEFILT) >= ARMV8_ID_AA64DFR0_EL1_TRACEFILT_SUPPORTED;
2084	pFeatures->fTrbe = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_TRACEBUFFER) >= ARMV8_ID_AA64DFR0_EL1_TRACEBUFFER_SUPPORTED;
2085	pFeatures->fMtPmu = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_MTPMU) == ARMV8_ID_AA64DFR0_EL1_MTPMU_SUPPORTED;
2086	pFeatures->fBrbe = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_BRBE) >= ARMV8_ID_AA64DFR0_EL1_BRBE_SUPPORTED;
2087	pFeatures->fBrbeV1p1 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_BRBE) >= ARMV8_ID_AA64DFR0_EL1_BRBE_SUPPORTED_V1P1;
2088	pFeatures->fHpmn0 = RT_BF_GET(u64IdReg, ARMV8_ID_AA64DFR0_EL1_HPMN0) >= ARMV8_ID_AA64DFR0_EL1_HPMN0_SUPPORTED;
2089
2090	return VINF_SUCCESS;
2091	}
2092	#endif /* defined(RT_ARCH_ARM64) \|\| defined(VBOX_VMM_TARGET_ARMV8) */
2093

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

source: vbox/trunk/src/VBox/VMM/VMMAll/CPUMAllCpuId.cpp

Download in other formats: