VirtualBox

source: vbox/trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-2-data16-intel.c16@ 104000

Last change on this file since 104000 was 104000, checked in by vboxsync, 8 months ago

ValKit/bs3-cpu-instr-2: Added shl,shr,sar,rol,ror,rcl&rcr tests (only intel data). bugref:10376

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.0 KB
Line 
1/* $Id: bs3-cpu-instr-2-data16-intel.c16 104000 2024-03-22 15:37:38Z vboxsync $ */
2/** @file
3 * BS3Kit - bs3-cpu-instr-2, bs3-cpu-instr-2-data16-intel.c16 - auto generated (do not edit).
4 */
5
6/*
7 * Copyright (C) 2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
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 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37#include <bs3kit.h>
38#include "bs3-cpu-instr-2.h"
39
40const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU8 = 32;
41const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shl_intel_TestDataU8[32] =
42{
43 { 0x00, 0x07, 0x011, 0x00, 0x044 },
44 { 0xff, 0x4d, 0x014, 0x00, 0x044 },
45 { 0x00, 0x0f, 0x054, 0x00, 0x044 },
46 { 0x72, 0x0c, 0x084, 0x00, 0x84c },
47 { 0x6a, 0xe7, 0x095, 0x00, 0x84d },
48 { 0xb0, 0x0e, 0x050, 0x00, 0x84c },
49 { 0x02, 0x02, 0x041, 0x08, 0x000 },
50 { 0x87, 0x00, 0x054, 0x87, 0x054 },
51 { 0x6f, 0x05, 0x0d1, 0xe0, 0x889 },
52 { 0x70, 0x02, 0x011, 0xc0, 0x88d },
53 { 0x39, 0x01, 0x095, 0x72, 0x004 },
54 { 0xd5, 0x01, 0x0d4, 0xaa, 0x085 },
55 { 0x77, 0x00, 0x090, 0x77, 0x090 },
56 { 0x5c, 0x02, 0x814, 0x70, 0x809 },
57 { 0x9f, 0x01, 0x044, 0x3e, 0x809 },
58 { 0xd9, 0x01, 0x001, 0xb2, 0x085 },
59 { 0x66, 0x08, 0x014, 0x00, 0x84c },
60 { 0x24, 0x09, 0x090, 0x00, 0x044 },
61 { 0x14, 0x09, 0x050, 0x00, 0x044 },
62 { 0xe2, 0x09, 0x805, 0x00, 0x044 },
63 { 0xee, 0x09, 0x0c0, 0x00, 0x044 },
64 { 0x5e, 0x09, 0x0d0, 0x00, 0x84c },
65 { 0x9f, 0x09, 0x081, 0x00, 0x84c },
66 { 0xc0, 0x09, 0x0c5, 0x00, 0x044 },
67 { 0x4a, 0x09, 0x050, 0x00, 0x84c },
68 { 0xec, 0x09, 0x0c5, 0x00, 0x044 },
69 { 0xfc, 0x04, 0x051, 0xc0, 0x085 },
70 { 0x3b, 0x05, 0x095, 0x60, 0x005 },
71 { 0x8e, 0x4d, 0x851, 0x00, 0x84c },
72 { 0x84, 0x0f, 0x051, 0x00, 0x84c },
73 { 0x69, 0x07, 0x090, 0x80, 0x888 },
74 { 0x31, 0x06, 0x0d4, 0x40, 0x000 },
75};
76
77const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU16 = 32;
78const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shl_intel_TestDataU16[32] =
79{
80 { 0x0000, 0x07, 0x050, 0x0000, 0x044 },
81 { 0xffff, 0x0c, 0x005, 0xf000, 0x085 },
82 { 0x0000, 0x06, 0x0c4, 0x0000, 0x044 },
83 { 0x0293, 0x03, 0x0c1, 0x1498, 0x000 },
84 { 0xa53d, 0x03, 0x055, 0x29e8, 0x80d },
85 { 0x3c72, 0x05, 0x094, 0x8e40, 0x081 },
86 { 0x0006, 0x4d, 0x084, 0xc000, 0x084 },
87 { 0x9965, 0x00, 0x014, 0x9965, 0x014 },
88 { 0xb8f4, 0x0a, 0x004, 0xd000, 0x88d },
89 { 0x0209, 0x0e, 0x054, 0x4000, 0x004 },
90 { 0x7f8b, 0x37, 0x094, 0x0000, 0x84c },
91 { 0x0875, 0x07, 0x0c1, 0x3a80, 0x000 },
92 { 0x0036, 0x08, 0x0c5, 0x3600, 0x004 },
93 { 0xa289, 0x06, 0x080, 0xa240, 0x888 },
94 { 0xf2e7, 0x0b, 0x0d5, 0x3800, 0x005 },
95 { 0x4c00, 0x00, 0x090, 0x4c00, 0x090 },
96 { 0xc6fb, 0x0d, 0x0c4, 0x6000, 0x005 },
97 { 0x022e, 0x01, 0x040, 0x045c, 0x004 },
98 { 0x00f2, 0x10, 0x040, 0x0000, 0x044 },
99 { 0x71a7, 0x11, 0x090, 0x0000, 0x84c },
100 { 0x70db, 0x11, 0x0c0, 0x0000, 0x84c },
101 { 0x0095, 0x11, 0x091, 0x0000, 0x044 },
102 { 0x9c4b, 0x11, 0x0c0, 0x0000, 0x84c },
103 { 0x4bcd, 0x11, 0x041, 0x0000, 0x84c },
104 { 0x0001, 0x11, 0x014, 0x0000, 0x044 },
105 { 0x6d51, 0x0e, 0x040, 0x4000, 0x80c },
106 { 0x8e06, 0x01, 0x0c5, 0x1c0c, 0x80d },
107 { 0x0579, 0x03, 0x0c5, 0x2bc8, 0x000 },
108 { 0x2fb3, 0x01, 0x0d1, 0x5f66, 0x004 },
109 { 0x83ff, 0x03, 0x8c0, 0x1ff8, 0x808 },
110 { 0x001e, 0x0c, 0x011, 0xe000, 0x085 },
111 { 0x71f2, 0x0c, 0x004, 0x2000, 0x80d },
112};
113
114const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU32 = 36;
115const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shl_intel_TestDataU32[36] =
116{
117 { 0x00000000, 0x10, 0x0c5, 0x00000000, 0x044 },
118 { 0xffffffff, 0x29, 0x084, 0xfffffe00, 0x085 },
119 { 0x00000000, 0x2b, 0x011, 0x00000000, 0x044 },
120 { 0x00008a9c, 0x02, 0x045, 0x00022a70, 0x000 },
121 { 0xcad1aee5, 0x0f, 0x0c5, 0xd7728000, 0x084 },
122 { 0x3b1ee5ac, 0x1a, 0x011, 0xb0000000, 0x084 },
123 { 0x00e9e3ae, 0x13, 0x015, 0x1d700000, 0x005 },
124 { 0x0f9dfc7f, 0x1b, 0x000, 0xf8000000, 0x085 },
125 { 0x4d2641fc, 0x02, 0x005, 0x349907f0, 0x80d },
126 { 0x00929297, 0x13, 0x0c5, 0x94b80000, 0x084 },
127 { 0x1ba08fd6, 0x05, 0x804, 0x7411fac0, 0x005 },
128 { 0x7297c522, 0x14, 0x0c4, 0x52200000, 0x80c },
129 { 0x03bcca68, 0x01, 0x044, 0x077994d0, 0x000 },
130 { 0x8a7547bd, 0x28, 0x881, 0x7547bd00, 0x80c },
131 { 0x999ec2ce, 0x19, 0x050, 0x9c000000, 0x88d },
132 { 0x35ee5115, 0x1c, 0x814, 0x50000000, 0x005 },
133 { 0x943ff728, 0x0e, 0x095, 0xfdca0000, 0x88d },
134 { 0x91883f7e, 0x03, 0x005, 0x8c41fbf0, 0x88c },
135 { 0x00cf61da, 0x03, 0x010, 0x067b0ed0, 0x000 },
136 { 0x53796399, 0x00, 0x0d0, 0x53796399, 0x0d0 },
137 { 0xf1e6353c, 0x20, 0x014, 0xf1e6353c, 0x014 },
138 { 0x0000703c, 0x21, 0x0c5, 0x0000e078, 0x004 },
139 { 0xc04927cc, 0x21, 0x044, 0x80924f98, 0x081 },
140 { 0x4826e92b, 0x21, 0x001, 0x904dd256, 0x88c },
141 { 0x281bd70b, 0x21, 0x004, 0x5037ae16, 0x000 },
142 { 0xab401b92, 0x21, 0x0c4, 0x56803724, 0x80d },
143 { 0x51e99b7e, 0x21, 0x811, 0xa3d336fc, 0x88c },
144 { 0x00000140, 0x21, 0x044, 0x00000280, 0x000 },
145 { 0x72ab9823, 0x21, 0x000, 0xe5573046, 0x888 },
146 { 0x44f9e185, 0x21, 0x001, 0x89f3c30a, 0x88c },
147 { 0x003d05e9, 0x21, 0x085, 0x007a0bd2, 0x004 },
148 { 0x16c5c386, 0x21, 0x0c0, 0x2d8b870c, 0x004 },
149 { 0xf35b9b25, 0x21, 0x045, 0xe6b7364a, 0x081 },
150 { 0x000016c9, 0x21, 0x005, 0x00002d92, 0x000 },
151 { 0x8d7cf362, 0x21, 0x055, 0x1af9e6c4, 0x809 },
152 { 0x27af3776, 0x21, 0x041, 0x4f5e6eec, 0x000 },
153};
154
155const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU8 = 32;
156const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shr_intel_TestDataU8[32] =
157{
158 { 0x00, 0x06, 0x0c5, 0x00, 0x044 },
159 { 0xff, 0x0a, 0x0c0, 0x00, 0x84c },
160 { 0x00, 0x0b, 0x041, 0x00, 0x044 },
161 { 0x6f, 0x02, 0x000, 0x1b, 0x005 },
162 { 0x39, 0x84, 0x014, 0x03, 0x005 },
163 { 0x5c, 0x84, 0x004, 0x05, 0x005 },
164 { 0xf7, 0x01, 0x004, 0x7b, 0x80d },
165 { 0x43, 0x07, 0x045, 0x00, 0x045 },
166 { 0xd2, 0x0b, 0x004, 0x00, 0x84c },
167 { 0xe1, 0x01, 0x0d5, 0x70, 0x809 },
168 { 0x4c, 0x09, 0x091, 0x00, 0x044 },
169 { 0x4b, 0x02, 0x080, 0x12, 0x005 },
170 { 0x3a, 0x07, 0x0c4, 0x00, 0x044 },
171 { 0xfd, 0x8f, 0x094, 0x00, 0x84c },
172 { 0x13, 0x05, 0x000, 0x00, 0x045 },
173 { 0x56, 0x05, 0x004, 0x02, 0x001 },
174 { 0x01, 0xf2, 0x055, 0x00, 0x044 },
175 { 0xd1, 0x00, 0x801, 0xd1, 0x809 },
176 { 0x60, 0x08, 0x001, 0x00, 0x044 },
177 { 0x97, 0x0c, 0x0c4, 0x00, 0x84c },
178 { 0xb9, 0x02, 0x045, 0x2e, 0x80c },
179 { 0xc3, 0x00, 0x0c0, 0xc3, 0x0c0 },
180 { 0x57, 0x06, 0x045, 0x01, 0x000 },
181 { 0x2e, 0x08, 0x050, 0x00, 0x044 },
182 { 0xe1, 0x8f, 0x0d5, 0x00, 0x84c },
183 { 0xd1, 0x03, 0x0d4, 0x1a, 0x808 },
184 { 0x54, 0x02, 0x085, 0x15, 0x000 },
185 { 0x13, 0x00, 0x055, 0x13, 0x055 },
186 { 0x39, 0x00, 0x084, 0x39, 0x084 },
187 { 0xa7, 0x04, 0x005, 0x0a, 0x80c },
188 { 0x8a, 0x04, 0x085, 0x08, 0x809 },
189 { 0x80, 0x05, 0x810, 0x04, 0x808 },
190};
191
192const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU16 = 32;
193const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shr_intel_TestDataU16[32] =
194{
195 { 0x0000, 0x09, 0x014, 0x0000, 0x044 },
196 { 0xffff, 0x0c, 0x0c4, 0x000f, 0x80d },
197 { 0x0000, 0x10, 0x095, 0x0000, 0x044 },
198 { 0x0041, 0x03, 0x085, 0x0008, 0x000 },
199 { 0x8c87, 0x10, 0x054, 0x0000, 0x84d },
200 { 0x290e, 0x04, 0x0d0, 0x0290, 0x005 },
201 { 0x01be, 0x10, 0x080, 0x0000, 0x044 },
202 { 0x8a67, 0x09, 0x0c4, 0x0045, 0x808 },
203 { 0x8716, 0x02, 0x0c5, 0x21c5, 0x80d },
204 { 0x012c, 0x4d, 0x014, 0x0000, 0x044 },
205 { 0x7db7, 0x05, 0x041, 0x03ed, 0x005 },
206 { 0xd419, 0x01, 0x801, 0x6a0c, 0x80d },
207 { 0x001f, 0x07, 0x045, 0x0000, 0x044 },
208 { 0x8244, 0x0e, 0x0d5, 0x0002, 0x808 },
209 { 0x9097, 0x0f, 0x055, 0x0001, 0x808 },
210 { 0x0015, 0x07, 0x010, 0x0000, 0x044 },
211 { 0x3f54, 0x1d, 0x084, 0x0000, 0x044 },
212 { 0x72e1, 0x00, 0x014, 0x72e1, 0x014 },
213 { 0x77a8, 0x11, 0x085, 0x0000, 0x044 },
214 { 0x50be, 0x11, 0x894, 0x0000, 0x044 },
215 { 0x00de, 0x11, 0x854, 0x0000, 0x044 },
216 { 0x0097, 0x11, 0x800, 0x0000, 0x044 },
217 { 0x04eb, 0x11, 0x000, 0x0000, 0x044 },
218 { 0x00cd, 0x00, 0x084, 0x00cd, 0x084 },
219 { 0x0054, 0x11, 0x0d4, 0x0000, 0x044 },
220 { 0xe5fe, 0x11, 0x0d0, 0x0000, 0x84c },
221 { 0xe0d4, 0x01, 0x0d0, 0x706a, 0x80c },
222 { 0x2739, 0x11, 0x0d1, 0x0000, 0x044 },
223 { 0x507e, 0x11, 0x0c4, 0x0000, 0x044 },
224 { 0x8562, 0x11, 0x054, 0x0000, 0x84c },
225 { 0x00a6, 0x11, 0x010, 0x0000, 0x044 },
226 { 0xe754, 0x11, 0x014, 0x0000, 0x84c },
227};
228
229const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU32 = 36;
230const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shr_intel_TestDataU32[36] =
231{
232 { 0x00000000, 0x17, 0x094, 0x00000000, 0x044 },
233 { 0xffffffff, 0x1a, 0x0d0, 0x0000003f, 0x80d },
234 { 0x00000000, 0x36, 0x081, 0x00000000, 0x044 },
235 { 0x0003ab40, 0x0e, 0x0d1, 0x0000000e, 0x001 },
236 { 0x5ba34261, 0x13, 0x084, 0x00000b74, 0x004 },
237 { 0x46358abd, 0x1a, 0x090, 0x00000011, 0x005 },
238 { 0x0000022c, 0x14, 0x014, 0x00000000, 0x044 },
239 { 0x941dacfe, 0x03, 0x0d4, 0x1283b59f, 0x80d },
240 { 0xb6276aa3, 0x16, 0x0c1, 0x000002d8, 0x80d },
241 { 0x006480e8, 0x38, 0x044, 0x00000000, 0x044 },
242 { 0xd3e0701e, 0x03, 0x810, 0x1a7c0e03, 0x80d },
243 { 0x590a0b3c, 0x1b, 0x050, 0x0000000b, 0x000 },
244 { 0x00009f84, 0x0e, 0x015, 0x00000002, 0x000 },
245 { 0xd40e517c, 0x00, 0x044, 0xd40e517c, 0x044 },
246 { 0xde09bd33, 0x00, 0x051, 0xde09bd33, 0x051 },
247 { 0x00a7dace, 0x15, 0x011, 0x00000005, 0x004 },
248 { 0xe7957739, 0x1c, 0x0d1, 0x0000000e, 0x808 },
249 { 0x717441e0, 0x1d, 0x051, 0x00000003, 0x005 },
250 { 0x3a37efb1, 0x06, 0x011, 0x00e8dfbe, 0x005 },
251 { 0x42556dd1, 0x01, 0x084, 0x212ab6e8, 0x005 },
252 { 0xb2b8c43c, 0x20, 0x080, 0xb2b8c43c, 0x080 },
253 { 0x000078da, 0x21, 0x044, 0x00003c6d, 0x000 },
254 { 0xc84db7a5, 0x21, 0x815, 0x6426dbd2, 0x80d },
255 { 0xae7cbaeb, 0x21, 0x095, 0x573e5d75, 0x809 },
256 { 0x00000021, 0x21, 0x885, 0x00000010, 0x001 },
257 { 0x96b5b537, 0x21, 0x085, 0x4b5ada9b, 0x809 },
258 { 0xd1416dfc, 0x21, 0x095, 0x68a0b6fe, 0x808 },
259 { 0x0f46742f, 0x21, 0x091, 0x07a33a17, 0x005 },
260 { 0x01ebd255, 0x21, 0x085, 0x00f5e92a, 0x001 },
261 { 0x8e6d058b, 0x21, 0x804, 0x473682c5, 0x80d },
262 { 0x0164c0ef, 0x21, 0x0c5, 0x00b26077, 0x005 },
263 { 0x06774b52, 0x21, 0x0d0, 0x033ba5a9, 0x004 },
264 { 0xbe3ab048, 0x21, 0x001, 0x5f1d5824, 0x80c },
265 { 0x0556e898, 0x21, 0x045, 0x02ab744c, 0x000 },
266 { 0x33a220c0, 0x21, 0x895, 0x19d11060, 0x004 },
267 { 0x42b272d4, 0x01, 0x0c0, 0x2159396a, 0x004 },
268};
269
270const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU8 = 32;
271const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_sar_intel_TestDataU8[32] =
272{
273 { 0x00, 0x04, 0x0c1, 0x00, 0x044 },
274 { 0xff, 0x07, 0x0c0, 0xff, 0x085 },
275 { 0x00, 0x08, 0x0c1, 0x00, 0x044 },
276 { 0x09, 0x06, 0x004, 0x00, 0x044 },
277 { 0xe8, 0x01, 0x094, 0xf4, 0x080 },
278 { 0x2f, 0x00, 0x090, 0x2f, 0x090 },
279 { 0x4d, 0x05, 0x0d4, 0x02, 0x000 },
280 { 0xad, 0x01, 0x055, 0xd6, 0x081 },
281 { 0xcb, 0x21, 0x0d5, 0xe5, 0x081 },
282 { 0x8e, 0x08, 0x041, 0xff, 0x085 },
283 { 0x22, 0x03, 0x054, 0x04, 0x000 },
284 { 0x19, 0x02, 0x080, 0x06, 0x004 },
285 { 0xf0, 0x01, 0x0c1, 0xf8, 0x080 },
286 { 0xb2, 0x06, 0x004, 0xfe, 0x081 },
287 { 0xda, 0x03, 0x044, 0xfb, 0x080 },
288 { 0x48, 0x09, 0x800, 0x00, 0x044 },
289 { 0x03, 0x06, 0x011, 0x00, 0x044 },
290 { 0xf7, 0x02, 0x051, 0xfd, 0x081 },
291 { 0x58, 0x04, 0x0d0, 0x05, 0x005 },
292 { 0x4a, 0x07, 0x011, 0x00, 0x045 },
293 { 0x89, 0x02, 0x0c0, 0xe2, 0x084 },
294 { 0x4c, 0x00, 0x894, 0x4c, 0x89c },
295 { 0xd9, 0x06, 0x0c1, 0xff, 0x084 },
296 { 0x98, 0x07, 0x045, 0xff, 0x084 },
297 { 0x8e, 0x00, 0x084, 0x8e, 0x084 },
298 { 0x99, 0x04, 0x050, 0xf9, 0x085 },
299 { 0x91, 0x09, 0x011, 0xff, 0x085 },
300 { 0x51, 0x06, 0x005, 0x01, 0x000 },
301 { 0x97, 0x03, 0x050, 0xf2, 0x081 },
302 { 0xa8, 0x05, 0x885, 0xfd, 0x080 },
303 { 0x00, 0x58, 0x091, 0x00, 0x044 },
304 { 0x6d, 0x07, 0x0d5, 0x00, 0x045 },
305};
306
307const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU16 = 32;
308const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_sar_intel_TestDataU16[32] =
309{
310 { 0x0000, 0x1b, 0x040, 0x0000, 0x044 },
311 { 0xffff, 0x0c, 0x005, 0xffff, 0x085 },
312 { 0x0000, 0x05, 0x0d4, 0x0000, 0x044 },
313 { 0x0117, 0x1f, 0x090, 0x0000, 0x044 },
314 { 0xf6b9, 0x0b, 0x004, 0xfffe, 0x081 },
315 { 0x59fe, 0x05, 0x0d1, 0x02cf, 0x005 },
316 { 0x15b0, 0x13, 0x0c4, 0x0000, 0x044 },
317 { 0x950c, 0x0f, 0x000, 0xffff, 0x084 },
318 { 0x588f, 0x01, 0x090, 0x2c47, 0x005 },
319 { 0x073a, 0x07, 0x0c1, 0x000e, 0x000 },
320 { 0x02c6, 0x19, 0x091, 0x0000, 0x044 },
321 { 0x1ec5, 0x09, 0x814, 0x000f, 0x004 },
322 { 0x003c, 0x00, 0x0c5, 0x003c, 0x0c5 },
323 { 0xbd79, 0xf2, 0x0c1, 0xffff, 0x085 },
324 { 0x3441, 0x04, 0x885, 0x0344, 0x004 },
325 { 0x00f4, 0x05, 0x091, 0x0007, 0x001 },
326 { 0x4087, 0x58, 0x014, 0x0000, 0x044 },
327 { 0xf2f9, 0x10, 0x081, 0xffff, 0x085 },
328 { 0x14a6, 0x11, 0x011, 0x0000, 0x044 },
329 { 0x8ee5, 0x00, 0x895, 0x8ee5, 0x89d },
330 { 0x0e61, 0x11, 0x051, 0x0000, 0x044 },
331 { 0x0003, 0x11, 0x011, 0x0000, 0x044 },
332 { 0x74fc, 0x11, 0x0c1, 0x0000, 0x044 },
333 { 0xc181, 0x11, 0x004, 0xffff, 0x085 },
334 { 0x0014, 0x11, 0x051, 0x0000, 0x044 },
335 { 0x7557, 0x11, 0x050, 0x0000, 0x044 },
336 { 0x5a99, 0x11, 0x081, 0x0000, 0x044 },
337 { 0x3b3f, 0x11, 0x091, 0x0000, 0x044 },
338 { 0x9f4f, 0x11, 0x010, 0xffff, 0x085 },
339 { 0x7eb4, 0x11, 0x851, 0x0000, 0x044 },
340 { 0x03fe, 0x11, 0x0c0, 0x0000, 0x044 },
341 { 0xcff1, 0x11, 0x0d5, 0xffff, 0x085 },
342};
343
344const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU32 = 36;
345const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_sar_intel_TestDataU32[36] =
346{
347 { 0x00000000, 0x37, 0x081, 0x00000000, 0x044 },
348 { 0xffffffff, 0x6e, 0x0d4, 0xffffffff, 0x085 },
349 { 0x00000000, 0x01, 0x044, 0x00000000, 0x044 },
350 { 0x00007073, 0xbb, 0x054, 0x00000000, 0x044 },
351 { 0xe882fc36, 0x14, 0x0c4, 0xfffffe88, 0x084 },
352 { 0xf20e4754, 0x0c, 0x0d5, 0xffff20e4, 0x084 },
353 { 0x00236f22, 0x08, 0x0d0, 0x0000236f, 0x004 },
354 { 0xc99e660f, 0x21, 0x805, 0xe4cf3307, 0x081 },
355 { 0xd3c9d39b, 0x03, 0x044, 0xfa793a73, 0x080 },
356 { 0x00000c96, 0x02, 0x000, 0x00000325, 0x001 },
357 { 0xaa9fd6aa, 0x16, 0x091, 0xfffffeaa, 0x084 },
358 { 0x49ce0f9a, 0x10, 0x005, 0x000049ce, 0x000 },
359 { 0x00018abb, 0x0f, 0x084, 0x00000003, 0x004 },
360 { 0xffff7314, 0x12, 0x015, 0xffffffff, 0x085 },
361 { 0xc4dd3e52, 0x10, 0x0d0, 0xffffc4dd, 0x084 },
362 { 0x0047b916, 0x0b, 0x095, 0x000008f7, 0x000 },
363 { 0x3a156d99, 0x0d, 0x055, 0x0001d0ab, 0x000 },
364 { 0xf66af462, 0x0a, 0x004, 0xfffd9abd, 0x084 },
365 { 0x0000254f, 0x0f, 0x054, 0x00000000, 0x044 },
366 { 0x1548b678, 0x00, 0x0c5, 0x1548b678, 0x0c5 },
367 { 0xd57435b1, 0x20, 0x010, 0xd57435b1, 0x010 },
368 { 0x6eeba1d1, 0x07, 0x044, 0x00ddd743, 0x001 },
369 { 0xc64fa3c3, 0x05, 0x055, 0xfe327d1e, 0x084 },
370 { 0xc10e73ec, 0x3e, 0x005, 0xffffffff, 0x084 },
371 { 0x00061fc8, 0x79, 0x015, 0x00000000, 0x044 },
372 { 0xc52c3e4a, 0x00, 0x845, 0xc52c3e4a, 0x84d },
373 { 0x5784f61b, 0xc6, 0x004, 0x015e13d8, 0x004 },
374 { 0x000003d3, 0x00, 0x0c4, 0x000003d3, 0x0c4 },
375 { 0x362411d9, 0x27, 0x0d0, 0x006c4823, 0x001 },
376 { 0x1bf4816e, 0x0c, 0x010, 0x0001bf48, 0x004 },
377 { 0x0000072e, 0x0d, 0x044, 0x00000000, 0x044 },
378 { 0x1591ad0c, 0x37, 0x890, 0x0000002b, 0x004 },
379 { 0xdcfbcac7, 0x02, 0x050, 0xf73ef2b1, 0x085 },
380 { 0x0000356b, 0x1a, 0x0d5, 0x00000000, 0x044 },
381 { 0x43305103, 0x0b, 0x095, 0x0008660a, 0x004 },
382 { 0xa64c561c, 0x08, 0x014, 0xffa64c56, 0x084 },
383};
384
385const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU8 = 32;
386const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rol_intel_TestDataU8[32] =
387{
388 { 0x00, 0x03, 0x0c4, 0x00, 0x0c4 },
389 { 0xff, 0x08, 0x0d4, 0xff, 0x0d5 },
390 { 0x00, 0x02, 0x080, 0x00, 0x080 },
391 { 0x3e, 0x02, 0x845, 0xf8, 0x04c }, /* OF/Ib */
392 { 0xb3, 0x02, 0x001, 0xce, 0x800 }, /* OF/Ib */
393 { 0x79, 0x02, 0x815, 0xe5, 0x81d },
394 { 0x9d, 0x01, 0x055, 0x3b, 0x85d },
395 { 0x68, 0x02, 0x844, 0xa1, 0x84d },
396 { 0x82, 0x05, 0x095, 0x50, 0x894 }, /* OF/Ib */
397 { 0x4f, 0x00, 0x001, 0x4f, 0x001 },
398 { 0x20, 0x00, 0x084, 0x20, 0x084 },
399 { 0x4c, 0x05, 0x081, 0x89, 0x881 }, /* OF/Ib */
400 { 0x83, 0x03, 0x091, 0x1c, 0x890 }, /* OF/Ib */
401 { 0x94, 0x05, 0x051, 0x92, 0x850 }, /* OF/Ib */
402 { 0x25, 0x01, 0x0d5, 0x4a, 0x0d4 },
403 { 0xfa, 0x04, 0x845, 0xaf, 0x04d }, /* OF/Ib */
404 { 0x91, 0x00, 0x0d4, 0x91, 0x0d4 },
405 { 0x39, 0x09, 0x090, 0x72, 0x090 },
406 { 0x95, 0x09, 0x045, 0x2b, 0x845 }, /* OF/Ib */
407 { 0xf5, 0x09, 0x085, 0xeb, 0x085 },
408 { 0x48, 0x01, 0x0c1, 0x90, 0x8c8 },
409 { 0x77, 0x01, 0x0c4, 0xee, 0x8cc },
410 { 0x9f, 0x09, 0x004, 0x3f, 0x805 }, /* OF/Ib */
411 { 0x82, 0x08, 0x094, 0x82, 0x894 }, /* OF/Ib */
412 { 0x4e, 0x09, 0x044, 0x9c, 0x844 }, /* OF/Ib */
413 { 0x92, 0x09, 0x085, 0x25, 0x885 }, /* OF/Ib */
414 { 0xac, 0x09, 0x051, 0x59, 0x851 }, /* OF/Ib */
415 { 0x16, 0x09, 0x000, 0x2c, 0x000 },
416 { 0xf7, 0x09, 0x0c1, 0xef, 0x0c1 },
417 { 0x15, 0x08, 0x0c5, 0x15, 0x0c5 },
418 { 0xb9, 0x09, 0x044, 0x73, 0x845 }, /* OF/Ib */
419 { 0x94, 0x09, 0x890, 0x29, 0x899 },
420};
421
422const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU16 = 32;
423const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rol_intel_TestDataU16[32] =
424{
425 { 0x0000, 0x03, 0x085, 0x0000, 0x084 },
426 { 0xffff, 0x0b, 0x090, 0xffff, 0x091 },
427 { 0x0000, 0x05, 0x004, 0x0000, 0x004 },
428 { 0x0000, 0x01, 0x0c1, 0x0000, 0x0c0 },
429 { 0x5978, 0x0a, 0x015, 0xe165, 0x815 }, /* OF/Ib */
430 { 0xeef7, 0x0a, 0x055, 0xdfbb, 0x055 },
431 { 0x07b7, 0x06, 0x085, 0xedc1, 0x085 },
432 { 0xd614, 0x06, 0x001, 0x8535, 0x001 },
433 { 0x02c5, 0x03, 0x014, 0x1628, 0x014 },
434 { 0x0012, 0x09, 0x014, 0x2400, 0x014 },
435 { 0x801f, 0x05, 0x095, 0x03f0, 0x894 }, /* OF/Ib */
436 { 0xdcc0, 0x09, 0x090, 0x81b9, 0x091 },
437 { 0x2034, 0x0f, 0x0c5, 0x101a, 0x0c4 },
438 { 0x2dea, 0x15, 0x081, 0xbd45, 0x081 },
439 { 0xa6e8, 0x01, 0x0d4, 0x4dd1, 0x8dd },
440 { 0x0f48, 0x06, 0x0c1, 0xd203, 0x0c1 },
441 { 0x7730, 0x00, 0x0d0, 0x7730, 0x0d0 },
442 { 0xa521, 0x10, 0x0c0, 0xa521, 0x8c1 }, /* OF/Ib */
443 { 0x00c2, 0x11, 0x895, 0x0184, 0x09c }, /* OF/Ib */
444 { 0x62c8, 0x11, 0x041, 0xc590, 0x840 }, /* OF/Ib */
445 { 0x3002, 0x11, 0x084, 0x6004, 0x084 },
446 { 0x001d, 0x11, 0x091, 0x003a, 0x090 },
447 { 0x5e16, 0x11, 0x0d4, 0xbc2c, 0x8d4 }, /* OF/Ib */
448 { 0xd7ad, 0x11, 0x885, 0xaf5b, 0x08d }, /* OF/Ib */
449 { 0x021a, 0x01, 0x001, 0x0434, 0x000 },
450 { 0x3147, 0x11, 0x004, 0x628e, 0x004 },
451 { 0xc032, 0x11, 0x015, 0x8065, 0x015 },
452 { 0x0012, 0x11, 0x815, 0x0024, 0x01c }, /* OF/Ib */
453 { 0xd4f4, 0x00, 0x0c0, 0xd4f4, 0x0c0 },
454 { 0x9665, 0x11, 0x085, 0x2ccb, 0x885 }, /* OF/Ib */
455 { 0x0854, 0x11, 0x004, 0x10a8, 0x004 },
456 { 0x9360, 0x00, 0x000, 0x9360, 0x000 },
457};
458
459const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU32 = 36;
460const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rol_intel_TestDataU32[36] =
461{
462 { 0x00000000, 0x00, 0x090, 0x00000000, 0x090 },
463 { 0xffffffff, 0x38, 0x051, 0xffffffff, 0x051 },
464 { 0x00000000, 0x30, 0x0d0, 0x00000000, 0x0d0 },
465 { 0x0001cdad, 0x31, 0x010, 0x9b5a0003, 0x011 },
466 { 0x09cd42c8, 0x12, 0x084, 0x0b202735, 0x085 },
467 { 0xec97d4bc, 0x16, 0x090, 0x2f3b25f5, 0x091 },
468 { 0x00001c42, 0x0b, 0x041, 0x00e21000, 0x040 },
469 { 0x2ce39bb6, 0x13, 0x081, 0xddb1671c, 0x080 },
470 { 0xdaee3a82, 0x1e, 0x0d4, 0xb6bb8ea0, 0x0d4 },
471 { 0x3417bb44, 0xe7, 0x0c1, 0x0bdda21a, 0x0c0 },
472 { 0xcf43cfca, 0x9a, 0x884, 0x2b3d0f3f, 0x08d }, /* OF/Ib */
473 { 0x55059da1, 0x0f, 0x091, 0xced0aa82, 0x890 }, /* OF/Ib */
474 { 0x0000008a, 0x19, 0x005, 0x14000001, 0x005 },
475 { 0x5ed9f755, 0x19, 0x0d0, 0xaabdb3ee, 0x8d0 }, /* OF/Ib */
476 { 0x0e5e5842, 0x00, 0x0c4, 0x0e5e5842, 0x0c4 },
477 { 0x00392bad, 0x1f, 0x881, 0x801c95d6, 0x088 }, /* OF/Ib */
478 { 0x7d88e6f7, 0xb0, 0x081, 0xe6f77d88, 0x880 }, /* OF/Ib */
479 { 0x4d49b56b, 0x1d, 0x894, 0x69a936ad, 0x89d },
480 { 0x0007f940, 0x1b, 0x854, 0x00003fca, 0x05c }, /* OF/Ib */
481 { 0x2689747e, 0x01, 0x055, 0x4d12e8fc, 0x054 },
482 { 0x27f8cabb, 0x20, 0x045, 0x27f8cabb, 0x045 },
483 { 0x00000425, 0x21, 0x044, 0x0000084a, 0x044 },
484 { 0xd3e72d9c, 0x21, 0x095, 0xa7ce5b39, 0x095 },
485 { 0xdb286ad4, 0x21, 0x085, 0xb650d5a9, 0x085 },
486 { 0x0056b701, 0x21, 0x010, 0x00ad6e02, 0x010 },
487 { 0xe7c99530, 0x21, 0x014, 0xcf932a61, 0x015 },
488 { 0x5dd7d3ee, 0x21, 0x894, 0xbbafa7dc, 0x89c },
489 { 0x00000130, 0x21, 0x090, 0x00000260, 0x090 },
490 { 0x61b905e7, 0x21, 0x091, 0xc3720bce, 0x898 },
491 { 0xd7695d4c, 0x21, 0x0d5, 0xaed2ba99, 0x0d5 },
492 { 0x0000000b, 0x21, 0x001, 0x00000016, 0x000 },
493 { 0x513f9c29, 0x21, 0x041, 0xa27f3852, 0x848 },
494 { 0x1a8a3688, 0x21, 0x005, 0x35146d10, 0x004 },
495 { 0x00000311, 0x21, 0x091, 0x00000622, 0x090 },
496 { 0x53c7dbbe, 0x21, 0x0c1, 0xa78fb77c, 0x8c8 },
497 { 0x6cda0551, 0x21, 0x0c1, 0xd9b40aa2, 0x8c8 },
498};
499
500const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU8 = 32;
501const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_ror_intel_TestDataU8[32] =
502{
503 { 0x00, 0x0a, 0x895, 0x00, 0x09c }, /* OF/Ib */
504 { 0xff, 0x00, 0x091, 0xff, 0x091 },
505 { 0x00, 0x01, 0x0c0, 0x00, 0x0c0 },
506 { 0x3b, 0x07, 0x090, 0x76, 0x890 }, /* OF/Ib */
507 { 0xfc, 0x9a, 0x0c5, 0x3f, 0x8c4 }, /* OF/Ib */
508 { 0x9f, 0x02, 0x095, 0xe7, 0x095 },
509 { 0x68, 0x07, 0x040, 0xd0, 0x041 },
510 { 0x06, 0x0f, 0x084, 0x0c, 0x084 },
511 { 0x1e, 0x07, 0x085, 0x3c, 0x084 },
512 { 0x35, 0x0a, 0x080, 0x4d, 0x880 }, /* OF/Ib */
513 { 0xf7, 0x04, 0x801, 0x7f, 0x008 }, /* OF/Ib */
514 { 0x68, 0x03, 0x0d5, 0x0d, 0x0d4 },
515 { 0x5e, 0x06, 0x850, 0x79, 0x058 }, /* OF/Ib */
516 { 0xb4, 0x07, 0x0d0, 0x69, 0x8d0 }, /* OF/Ib */
517 { 0xdc, 0x03, 0x0c0, 0x9b, 0x8c1 }, /* OF/Ib */
518 { 0xf0, 0x01, 0x0d5, 0x78, 0x8dc },
519 { 0x7d, 0x03, 0x044, 0xaf, 0x845 }, /* OF/Ib */
520 { 0xba, 0x08, 0x004, 0xba, 0x805 }, /* OF/Ib */
521 { 0xa5, 0x08, 0x015, 0xa5, 0x015 },
522 { 0x3f, 0x09, 0x044, 0x9f, 0x845 }, /* OF/Ib */
523 { 0x36, 0x01, 0x094, 0x1b, 0x094 },
524 { 0xab, 0x09, 0x050, 0xd5, 0x051 },
525 { 0x13, 0x09, 0x051, 0x89, 0x851 }, /* OF/Ib */
526 { 0xb5, 0x09, 0x055, 0xda, 0x055 },
527 { 0xdb, 0x09, 0x090, 0xed, 0x091 },
528 { 0x1a, 0x09, 0x040, 0x0d, 0x040 },
529 { 0x22, 0x09, 0x014, 0x11, 0x014 },
530 { 0xb6, 0x09, 0x011, 0x5b, 0x810 }, /* OF/Ib */
531 { 0xdf, 0x09, 0x080, 0xef, 0x081 },
532 { 0x05, 0x00, 0x0c5, 0x05, 0x0c5 },
533 { 0xe1, 0x09, 0x040, 0xf0, 0x041 },
534 { 0xe8, 0x01, 0x081, 0x74, 0x888 },
535};
536
537const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU16 = 32;
538const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_ror_intel_TestDataU16[32] =
539{
540 { 0x0000, 0x0b, 0x0c4, 0x0000, 0x0c4 },
541 { 0xffff, 0x0e, 0x011, 0xffff, 0x011 },
542 { 0x0000, 0x09, 0x810, 0x0000, 0x018 }, /* OF/Ib */
543 { 0x21f5, 0x0d, 0x011, 0x0fa9, 0x810 }, /* OF/Ib */
544 { 0x1c1b, 0x06, 0x0d4, 0x6c70, 0x8d4 }, /* OF/Ib */
545 { 0xa983, 0x0f, 0x091, 0x5307, 0x090 },
546 { 0x0017, 0x0b, 0x045, 0x02e0, 0x844 }, /* OF/Ib */
547 { 0xb954, 0x08, 0x0d4, 0x54b9, 0x8d4 }, /* OF/Ib */
548 { 0xfa4f, 0x07, 0x094, 0x9ff4, 0x095 },
549 { 0x239e, 0x09, 0x055, 0xcf11, 0x055 },
550 { 0x911e, 0x07, 0x010, 0x3d22, 0x810 }, /* OF/Ib */
551 { 0xc130, 0x0e, 0x090, 0x04c3, 0x890 }, /* OF/Ib */
552 { 0x00fa, 0x07, 0x081, 0xf401, 0x081 },
553 { 0xe0bd, 0x02, 0x8c5, 0x782f, 0x0cc }, /* OF/Ib */
554 { 0x885f, 0x00, 0x854, 0x885f, 0x85c },
555 { 0x0009, 0x0e, 0x081, 0x0024, 0x880 }, /* OF/Ib */
556 { 0x11a6, 0x1f, 0x0d5, 0x234c, 0x0d4 },
557 { 0xcb75, 0x01, 0x001, 0xe5ba, 0x001 },
558 { 0x0013, 0x10, 0x010, 0x0013, 0x810 }, /* OF/Ib */
559 { 0xe588, 0x11, 0x014, 0x72c4, 0x814 }, /* OF/Ib */
560 { 0x6b5c, 0x11, 0x015, 0x35ae, 0x014 },
561 { 0x008b, 0x11, 0x000, 0x8045, 0x801 }, /* OF/Ib */
562 { 0xaa0f, 0x11, 0x051, 0xd507, 0x051 },
563 { 0xf3a7, 0x11, 0x0d5, 0xf9d3, 0x0d5 },
564 { 0x000e, 0x11, 0x895, 0x0007, 0x09c }, /* OF/Ib */
565 { 0x1855, 0x11, 0x000, 0x8c2a, 0x801 }, /* OF/Ib */
566 { 0x40f1, 0x11, 0x004, 0xa078, 0x805 }, /* OF/Ib */
567 { 0x0b14, 0x11, 0x055, 0x058a, 0x054 },
568 { 0x0d26, 0x11, 0x085, 0x0693, 0x084 },
569 { 0x17bf, 0x11, 0x095, 0x8bdf, 0x895 }, /* OF/Ib */
570 { 0x0ba5, 0x11, 0x004, 0x85d2, 0x805 }, /* OF/Ib */
571 { 0x79f4, 0x11, 0x0c4, 0x3cfa, 0x0c4 },
572};
573
574const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU32 = 36;
575const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_ror_intel_TestDataU32[36] =
576{
577 { 0x00000000, 0x04, 0x095, 0x00000000, 0x094 },
578 { 0xffffffff, 0x11, 0x0c5, 0xffffffff, 0x0c5 },
579 { 0x00000000, 0x17, 0x000, 0x00000000, 0x000 },
580 { 0x000263ac, 0x17, 0x0c1, 0x04c75800, 0x0c0 },
581 { 0x4afa2b26, 0x0b, 0x810, 0x64c95f45, 0x018 }, /* OF/Ib */
582 { 0xc3817c0f, 0x15, 0x045, 0x0be07e1c, 0x044 },
583 { 0x0345b01b, 0x1e, 0x081, 0x0d16c06c, 0x880 }, /* OF/Ib */
584 { 0x8e863771, 0x2a, 0x015, 0xdc63a18d, 0x015 },
585 { 0xc9c56bde, 0x15, 0x0c1, 0x2b5ef64e, 0x8c0 }, /* OF/Ib */
586 { 0x00016164, 0x1f, 0x015, 0x0002c2c8, 0x014 },
587 { 0x5033d4fc, 0x13, 0x051, 0x7a9f8a06, 0x050 },
588 { 0x5b6af954, 0x0f, 0x050, 0xf2a8b6d5, 0x051 },
589 { 0x00009eb6, 0x00, 0x041, 0x00009eb6, 0x041 },
590 { 0x537ff2c2, 0x01, 0x091, 0x29bff961, 0x090 },
591 { 0x0654e632, 0xb0, 0x090, 0xe6320654, 0x091 },
592 { 0x00000f3f, 0x03, 0x084, 0xe00001e7, 0x885 }, /* OF/Ib */
593 { 0xdd9afec8, 0x07, 0x0c0, 0x91bb35fd, 0x8c1 }, /* OF/Ib */
594 { 0x32e71230, 0x3f, 0x015, 0x65ce2460, 0x014 },
595 { 0x016675c9, 0x39, 0x050, 0xb33ae480, 0x851 }, /* OF/Ib */
596 { 0xdf65ca9b, 0x20, 0x095, 0xdf65ca9b, 0x095 },
597 { 0xd8300a28, 0x21, 0x001, 0x6c180514, 0x808 },
598 { 0x00000b7a, 0x21, 0x004, 0x000005bd, 0x004 },
599 { 0xb518d684, 0x21, 0x010, 0x5a8c6b42, 0x818 },
600 { 0x72a957fd, 0x21, 0x0d5, 0xb954abfe, 0x8dd },
601 { 0x000007a7, 0x21, 0x0c5, 0x800003d3, 0x8cd },
602 { 0x1603b6be, 0x21, 0x0c0, 0x0b01db5f, 0x0c0 },
603 { 0xcabdc593, 0x21, 0x055, 0xe55ee2c9, 0x055 },
604 { 0x00017d03, 0x21, 0x015, 0x8000be81, 0x81d },
605 { 0xa2169ab1, 0x21, 0x090, 0xd10b4d58, 0x091 },
606 { 0x2360ea67, 0x21, 0x094, 0x91b07533, 0x89d },
607 { 0x00000184, 0x21, 0x095, 0x000000c2, 0x094 },
608 { 0x5b77fd29, 0x21, 0x015, 0xadbbfe94, 0x81d },
609 { 0x13dd8c43, 0x21, 0x0c4, 0x89eec621, 0x8cd },
610 { 0x000001cd, 0x21, 0x011, 0x800000e6, 0x819 },
611 { 0xf9fc8959, 0x00, 0x0c5, 0xf9fc8959, 0x0c5 },
612 { 0xbe23ab3a, 0x21, 0x0c5, 0x5f11d59d, 0x8cc },
613};
614
615const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU8 = 64;
616const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcl_intel_TestDataU8[64] =
617{
618 { 0x00, 0x0a, 0x0d0, 0x00, 0x0d0 },
619 { 0x00, 0x0a, 0x0d1, 0x01, 0x0d0 },
620 { 0xff, 0x01, 0x000, 0xfe, 0x001 },
621 { 0xff, 0x01, 0x001, 0xff, 0x001 },
622 { 0x00, 0x07, 0x044, 0x00, 0x044 },
623 { 0x00, 0x07, 0x045, 0x40, 0x044 },
624 { 0x83, 0x03, 0x890, 0x1a, 0x898 },
625 { 0x83, 0x03, 0x891, 0x1e, 0x898 },
626 { 0x8e, 0x06, 0x090, 0x91, 0x899 },
627 { 0x8e, 0x06, 0x091, 0xb1, 0x899 },
628 { 0x19, 0x00, 0x0d4, 0x19, 0x0d4 },
629 { 0x19, 0x00, 0x0d5, 0x19, 0x0d5 },
630 { 0x31, 0x00, 0x0c4, 0x31, 0x0c4 },
631 { 0x31, 0x00, 0x0c5, 0x31, 0x0c5 },
632 { 0x45, 0x03, 0x890, 0x29, 0x898 },
633 { 0x45, 0x03, 0x891, 0x2d, 0x898 },
634 { 0x02, 0x02, 0x050, 0x08, 0x050 },
635 { 0x02, 0x02, 0x051, 0x0a, 0x050 },
636 { 0x63, 0x00, 0x084, 0x63, 0x084 },
637 { 0x63, 0x00, 0x085, 0x63, 0x085 },
638 { 0xe4, 0x02, 0x0d0, 0x91, 0x0d1 },
639 { 0xe4, 0x02, 0x0d1, 0x93, 0x0d1 },
640 { 0xdf, 0x05, 0x8c4, 0xed, 0x0c5 },
641 { 0xdf, 0x05, 0x8c5, 0xfd, 0x0c5 },
642 { 0xd8, 0x01, 0x044, 0xb0, 0x045 },
643 { 0xd8, 0x01, 0x045, 0xb1, 0x045 },
644 { 0x34, 0x01, 0x000, 0x68, 0x000 },
645 { 0x34, 0x01, 0x001, 0x69, 0x000 },
646 { 0x1f, 0x07, 0x054, 0x87, 0x055 },
647 { 0x1f, 0x07, 0x055, 0xc7, 0x055 },
648 { 0xf1, 0x03, 0x0d0, 0x8b, 0x0d1 },
649 { 0xf1, 0x03, 0x0d1, 0x8f, 0x0d1 },
650 { 0x6a, 0x0f, 0x0d4, 0x8d, 0x8dc },
651 { 0x6a, 0x0f, 0x0d5, 0xad, 0x8dc },
652 { 0x2c, 0x00, 0x0c0, 0x2c, 0x0c0 },
653 { 0x2c, 0x00, 0x0c1, 0x2c, 0x0c1 },
654 { 0x0d, 0x08, 0x080, 0x06, 0x081 },
655 { 0x0d, 0x08, 0x081, 0x86, 0x081 },
656 { 0xa6, 0x09, 0x014, 0xa6, 0x014 },
657 { 0xa6, 0x09, 0x015, 0xa6, 0x015 },
658 { 0x7a, 0x09, 0x084, 0x7a, 0x084 },
659 { 0x7a, 0x09, 0x085, 0x7a, 0x085 },
660 { 0xbc, 0x08, 0x0c0, 0x5e, 0x8c8 },
661 { 0xbc, 0x08, 0x0c1, 0xde, 0x8c8 },
662 { 0x81, 0x09, 0x054, 0x81, 0x054 },
663 { 0x81, 0x09, 0x055, 0x81, 0x055 },
664 { 0x11, 0x09, 0x054, 0x11, 0x054 },
665 { 0x11, 0x09, 0x055, 0x11, 0x055 },
666 { 0x30, 0x09, 0x040, 0x30, 0x040 },
667 { 0x30, 0x09, 0x041, 0x30, 0x041 },
668 { 0x54, 0x00, 0x0d4, 0x54, 0x0d4 },
669 { 0x54, 0x00, 0x0d5, 0x54, 0x0d5 },
670 { 0x30, 0x08, 0x0c4, 0x18, 0x0c4 },
671 { 0x30, 0x08, 0x0c5, 0x98, 0x0c4 },
672 { 0xf3, 0x09, 0x850, 0xf3, 0x858 },
673 { 0xf3, 0x09, 0x851, 0xf3, 0x859 },
674 { 0x42, 0x09, 0x084, 0x42, 0x084 },
675 { 0x42, 0x09, 0x085, 0x42, 0x085 },
676 { 0x3a, 0x09, 0x0d0, 0x3a, 0x0d0 },
677 { 0x3a, 0x09, 0x0d1, 0x3a, 0x0d1 },
678 { 0x70, 0x09, 0x080, 0x70, 0x080 },
679 { 0x70, 0x09, 0x081, 0x70, 0x081 },
680 { 0x99, 0x08, 0x090, 0x4c, 0x899 },
681 { 0x99, 0x08, 0x091, 0xcc, 0x899 },
682};
683
684const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU16 = 64;
685const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcl_intel_TestDataU16[64] =
686{
687 { 0x0000, 0x15, 0x0d4, 0x0000, 0x0d4 },
688 { 0x0000, 0x15, 0x0d5, 0x0008, 0x0d4 },
689 { 0xffff, 0x06, 0x010, 0xffdf, 0x011 },
690 { 0xffff, 0x06, 0x011, 0xffff, 0x011 },
691 { 0x0000, 0x0d, 0x0d4, 0x0000, 0x0d4 },
692 { 0x0000, 0x0d, 0x0d5, 0x1000, 0x0d4 },
693 { 0x005f, 0x01, 0x040, 0x00be, 0x040 },
694 { 0x005f, 0x01, 0x041, 0x00bf, 0x040 },
695 { 0xd8e2, 0x0a, 0x010, 0x89b1, 0x011 },
696 { 0xd8e2, 0x0a, 0x011, 0x8bb1, 0x011 },
697 { 0xc938, 0x63, 0x050, 0x49c3, 0x050 },
698 { 0xc938, 0x63, 0x051, 0x49c7, 0x050 },
699 { 0x0059, 0x0e, 0x010, 0x400b, 0x010 },
700 { 0x0059, 0x0e, 0x011, 0x600b, 0x010 },
701 { 0xf068, 0x1d, 0x800, 0x8783, 0x000 },
702 { 0xf068, 0x1d, 0x801, 0x8f83, 0x000 },
703 { 0x2af7, 0x1d, 0x844, 0x7157, 0x045 },
704 { 0x2af7, 0x1d, 0x845, 0x7957, 0x045 },
705 { 0x3a57, 0x0a, 0x004, 0x5c74, 0x005 },
706 { 0x3a57, 0x0a, 0x005, 0x5e74, 0x005 },
707 { 0x107d, 0x07, 0x090, 0x3e84, 0x090 },
708 { 0x107d, 0x07, 0x091, 0x3ec4, 0x090 },
709 { 0x5a93, 0x02, 0x004, 0x6a4c, 0x80d },
710 { 0x5a93, 0x02, 0x005, 0x6a4e, 0x80d },
711 { 0x6d1c, 0x02, 0x084, 0xb470, 0x88d },
712 { 0x6d1c, 0x02, 0x085, 0xb472, 0x88d },
713 { 0xfb68, 0x06, 0x050, 0xda1f, 0x050 },
714 { 0xfb68, 0x06, 0x051, 0xda3f, 0x050 },
715 { 0x0cbf, 0x09, 0x010, 0x7e0c, 0x011 },
716 { 0x0cbf, 0x09, 0x011, 0x7f0c, 0x011 },
717 { 0x0062, 0x03, 0x000, 0x0310, 0x000 },
718 { 0x0062, 0x03, 0x001, 0x0314, 0x000 },
719 { 0xb266, 0x0b, 0x080, 0x32c9, 0x889 },
720 { 0xb266, 0x0b, 0x081, 0x36c9, 0x889 },
721 { 0xc650, 0x00, 0x880, 0xc650, 0x888 },
722 { 0xc650, 0x00, 0x881, 0xc650, 0x889 },
723 { 0x0351, 0x01, 0x014, 0x06a2, 0x014 },
724 { 0x0351, 0x01, 0x015, 0x06a3, 0x014 },
725 { 0x4bcc, 0x10, 0x800, 0x25e6, 0x808 },
726 { 0x4bcc, 0x10, 0x801, 0xa5e6, 0x808 },
727 { 0xcdea, 0x11, 0x080, 0xcdea, 0x080 },
728 { 0xcdea, 0x11, 0x081, 0xcdea, 0x081 },
729 { 0x0732, 0x11, 0x0d0, 0x0732, 0x0d0 },
730 { 0x0732, 0x11, 0x0d1, 0x0732, 0x0d1 },
731 { 0x351f, 0x11, 0x0c0, 0x351f, 0x0c0 },
732 { 0x351f, 0x11, 0x0c1, 0x351f, 0x0c1 },
733 { 0xf855, 0x11, 0x014, 0xf855, 0x014 },
734 { 0xf855, 0x11, 0x015, 0xf855, 0x015 },
735 { 0x0bc7, 0x11, 0x090, 0x0bc7, 0x090 },
736 { 0x0bc7, 0x11, 0x091, 0x0bc7, 0x091 },
737 { 0xf049, 0x11, 0x0c4, 0xf049, 0x0c4 },
738 { 0xf049, 0x11, 0x0c5, 0xf049, 0x0c5 },
739 { 0x05c8, 0x11, 0x010, 0x05c8, 0x010 },
740 { 0x05c8, 0x11, 0x011, 0x05c8, 0x011 },
741 { 0x0004, 0x11, 0x0c0, 0x0004, 0x0c0 },
742 { 0x0004, 0x11, 0x0c1, 0x0004, 0x0c1 },
743 { 0xdc1d, 0x11, 0x000, 0xdc1d, 0x000 },
744 { 0xdc1d, 0x11, 0x001, 0xdc1d, 0x001 },
745 { 0x3073, 0x11, 0x840, 0x3073, 0x848 },
746 { 0x3073, 0x11, 0x841, 0x3073, 0x849 },
747 { 0x0013, 0x11, 0x084, 0x0013, 0x084 },
748 { 0x0013, 0x11, 0x085, 0x0013, 0x085 },
749 { 0x8f57, 0x11, 0x094, 0x8f57, 0x094 },
750 { 0x8f57, 0x11, 0x095, 0x8f57, 0x095 },
751};
752
753const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU32 = 72;
754const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcl_intel_TestDataU32[72] =
755{
756 { 0x00000000, 0x05, 0x080, 0x00000000, 0x080 },
757 { 0x00000000, 0x05, 0x081, 0x00000010, 0x080 },
758 { 0xffffffff, 0x27, 0x040, 0xffffffbf, 0x041 },
759 { 0xffffffff, 0x27, 0x041, 0xffffffff, 0x041 },
760 { 0x00000000, 0x0d, 0x090, 0x00000000, 0x090 },
761 { 0x00000000, 0x0d, 0x091, 0x00001000, 0x090 },
762 { 0x00006a3c, 0x09, 0x010, 0x00d47800, 0x010 },
763 { 0x00006a3c, 0x09, 0x011, 0x00d47900, 0x010 },
764 { 0xf6d1580e, 0x13, 0x850, 0xc073db45, 0x050 },
765 { 0xf6d1580e, 0x13, 0x851, 0xc077db45, 0x050 },
766 { 0x6a668da7, 0x03, 0x0c0, 0x53346d39, 0x8c9 },
767 { 0x6a668da7, 0x03, 0x0c1, 0x53346d3d, 0x8c9 },
768 { 0x000308b6, 0xdc, 0x894, 0x60001845, 0x095 },
769 { 0x000308b6, 0xdc, 0x895, 0x68001845, 0x095 },
770 { 0x9c5e944a, 0x06, 0x080, 0x17a51293, 0x889 },
771 { 0x9c5e944a, 0x06, 0x081, 0x17a512b3, 0x889 },
772 { 0x5e7ee5e5, 0xfd, 0x014, 0xa5e7ee5e, 0x81c },
773 { 0x5e7ee5e5, 0xfd, 0x015, 0xb5e7ee5e, 0x81c },
774 { 0x00008f79, 0x28, 0x004, 0x008f7900, 0x004 },
775 { 0x00008f79, 0x28, 0x005, 0x008f7980, 0x004 },
776 { 0x4bfc7f14, 0x11, 0x0d0, 0xfe284bfc, 0x8d8 },
777 { 0x4bfc7f14, 0x11, 0x0d1, 0xfe294bfc, 0x8d8 },
778 { 0xeec3ba70, 0x0c, 0x0d0, 0x3ba70776, 0x0d0 },
779 { 0xeec3ba70, 0x0c, 0x0d1, 0x3ba70f76, 0x0d0 },
780 { 0x1f7cac12, 0x24, 0x054, 0xf7cac120, 0x055 },
781 { 0x1f7cac12, 0x24, 0x055, 0xf7cac128, 0x055 },
782 { 0x4cf2a312, 0x15, 0x0c0, 0x6244cf2a, 0x8c8 },
783 { 0x4cf2a312, 0x15, 0x0c1, 0x6254cf2a, 0x8c8 },
784 { 0x8b3eb75d, 0x03, 0x040, 0x59f5baea, 0x848 },
785 { 0x8b3eb75d, 0x03, 0x041, 0x59f5baee, 0x848 },
786 { 0x22264a2e, 0x05, 0x040, 0x44c945c2, 0x040 },
787 { 0x22264a2e, 0x05, 0x041, 0x44c945d2, 0x040 },
788 { 0x4cfb817c, 0x0c, 0x0c0, 0xb817c267, 0x8c9 },
789 { 0x4cfb817c, 0x0c, 0x0c1, 0xb817ca67, 0x8c9 },
790 { 0x95a35454, 0x05, 0x044, 0xb46a8a89, 0x84c },
791 { 0x95a35454, 0x05, 0x045, 0xb46a8a99, 0x84c },
792 { 0x02106301, 0x00, 0x010, 0x02106301, 0x010 },
793 { 0x02106301, 0x00, 0x011, 0x02106301, 0x011 },
794 { 0xb93e575a, 0x01, 0x014, 0x727caeb4, 0x81d },
795 { 0xb93e575a, 0x01, 0x015, 0x727caeb5, 0x81d },
796 { 0xf57b3fa8, 0x20, 0x094, 0xf57b3fa8, 0x094 },
797 { 0xf57b3fa8, 0x20, 0x095, 0xf57b3fa8, 0x095 },
798 { 0x00000fc5, 0x21, 0x080, 0x00001f8a, 0x080 },
799 { 0x00000fc5, 0x21, 0x081, 0x00001f8b, 0x080 },
800 { 0xee18ff3b, 0x21, 0x0d4, 0xdc31fe76, 0x0d5 },
801 { 0xee18ff3b, 0x21, 0x0d5, 0xdc31fe77, 0x0d5 },
802 { 0x23ec2b0f, 0x21, 0x094, 0x47d8561e, 0x094 },
803 { 0x23ec2b0f, 0x21, 0x095, 0x47d8561f, 0x094 },
804 { 0x00001757, 0x21, 0x090, 0x00002eae, 0x090 },
805 { 0x00001757, 0x21, 0x091, 0x00002eaf, 0x090 },
806 { 0x022247fd, 0x21, 0x804, 0x04448ffa, 0x004 },
807 { 0x022247fd, 0x21, 0x805, 0x04448ffb, 0x004 },
808 { 0x6ee4c757, 0x21, 0x0c0, 0xddc98eae, 0x8c8 },
809 { 0x6ee4c757, 0x21, 0x0c1, 0xddc98eaf, 0x8c8 },
810 { 0x06e5c690, 0x21, 0x050, 0x0dcb8d20, 0x050 },
811 { 0x06e5c690, 0x21, 0x051, 0x0dcb8d21, 0x050 },
812 { 0x28823604, 0x21, 0x004, 0x51046c08, 0x004 },
813 { 0x28823604, 0x21, 0x005, 0x51046c09, 0x004 },
814 { 0x7e7e1930, 0x21, 0x084, 0xfcfc3260, 0x88c },
815 { 0x7e7e1930, 0x21, 0x085, 0xfcfc3261, 0x88c },
816 { 0x00026f9f, 0x20, 0x054, 0x00026f9f, 0x054 },
817 { 0x00026f9f, 0x20, 0x055, 0x00026f9f, 0x055 },
818 { 0x904147c4, 0x21, 0x094, 0x20828f88, 0x89d },
819 { 0x904147c4, 0x21, 0x095, 0x20828f89, 0x89d },
820 { 0xed4da4ab, 0x21, 0x0d4, 0xda9b4956, 0x0d5 },
821 { 0xed4da4ab, 0x21, 0x0d5, 0xda9b4957, 0x0d5 },
822 { 0x000000d9, 0x21, 0x014, 0x000001b2, 0x014 },
823 { 0x000000d9, 0x21, 0x015, 0x000001b3, 0x014 },
824 { 0x09552d03, 0x21, 0x014, 0x12aa5a06, 0x014 },
825 { 0x09552d03, 0x21, 0x015, 0x12aa5a07, 0x014 },
826 { 0xb7a371ad, 0x21, 0x0d4, 0x6f46e35a, 0x8dd },
827 { 0xb7a371ad, 0x21, 0x0d5, 0x6f46e35b, 0x8dd },
828};
829
830const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU8 = 64;
831const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcr_intel_TestDataU8[64] =
832{
833 { 0x00, 0x02, 0x0c4, 0x00, 0x0c4 },
834 { 0x00, 0x02, 0x0c5, 0x40, 0x8cc },
835 { 0xff, 0x05, 0x010, 0xf7, 0x819 },
836 { 0xff, 0x05, 0x011, 0xff, 0x011 },
837 { 0x00, 0x01, 0x004, 0x00, 0x004 },
838 { 0x00, 0x01, 0x005, 0x80, 0x80c },
839 { 0x1e, 0x07, 0x094, 0x78, 0x094 },
840 { 0x1e, 0x07, 0x095, 0x7a, 0x89c },
841 { 0xc8, 0x06, 0x094, 0x43, 0x89c },
842 { 0xc8, 0x06, 0x095, 0x47, 0x094 },
843 { 0xa2, 0x0a, 0x050, 0x51, 0x858 },
844 { 0xa2, 0x0a, 0x051, 0xd1, 0x050 },
845 { 0x15, 0x00, 0x054, 0x15, 0x054 },
846 { 0x15, 0x00, 0x055, 0x15, 0x055 },
847 { 0x03, 0x00, 0x0c0, 0x03, 0x0c0 },
848 { 0x03, 0x00, 0x0c1, 0x03, 0x0c1 },
849 { 0xa6, 0x01, 0x040, 0x53, 0x848 },
850 { 0xa6, 0x01, 0x041, 0xd3, 0x040 },
851 { 0x97, 0x0c, 0x050, 0xd2, 0x859 },
852 { 0x97, 0x0c, 0x051, 0xf2, 0x051 },
853 { 0xb5, 0x05, 0x014, 0x55, 0x81d },
854 { 0xb5, 0x05, 0x015, 0x5d, 0x015 },
855 { 0x56, 0x03, 0x0d0, 0x8a, 0x0d1 },
856 { 0x56, 0x03, 0x0d1, 0xaa, 0x8d9 },
857 { 0xa0, 0x09, 0x0c0, 0xa0, 0x0c0 },
858 { 0xa0, 0x09, 0x0c1, 0xa0, 0x0c1 },
859 { 0xd2, 0x84, 0x090, 0x4d, 0x898 },
860 { 0xd2, 0x84, 0x091, 0x5d, 0x090 },
861 { 0x70, 0x06, 0x000, 0x81, 0x001 },
862 { 0x70, 0x06, 0x001, 0x85, 0x809 },
863 { 0x6c, 0x01, 0x004, 0x36, 0x004 },
864 { 0x6c, 0x01, 0x005, 0xb6, 0x80c },
865 { 0x1c, 0x0e, 0x004, 0xc0, 0x005 },
866 { 0x1c, 0x0e, 0x005, 0xc8, 0x80d },
867 { 0x27, 0x08, 0x884, 0x4e, 0x084 },
868 { 0x27, 0x08, 0x885, 0x4f, 0x88c },
869 { 0xf9, 0x04, 0x0c0, 0x2f, 0x8c9 },
870 { 0xf9, 0x04, 0x0c1, 0x3f, 0x0c1 },
871 { 0x1b, 0x01, 0x080, 0x0d, 0x081 },
872 { 0x1b, 0x01, 0x081, 0x8d, 0x889 },
873 { 0xd3, 0xa5, 0x080, 0x36, 0x889 },
874 { 0xd3, 0xa5, 0x081, 0x3e, 0x081 },
875 { 0xc7, 0x06, 0x000, 0x3b, 0x808 },
876 { 0xc7, 0x06, 0x001, 0x3f, 0x000 },
877 { 0x68, 0x01, 0x084, 0x34, 0x084 },
878 { 0x68, 0x01, 0x085, 0xb4, 0x88c },
879 { 0x2a, 0x05, 0x050, 0xa1, 0x050 },
880 { 0x2a, 0x05, 0x051, 0xa9, 0x858 },
881 { 0x8a, 0x0c, 0x0c4, 0x91, 0x8cc },
882 { 0x8a, 0x0c, 0x0c5, 0xb1, 0x0c4 },
883 { 0x89, 0x02, 0x0c0, 0xa2, 0x8c8 },
884 { 0x89, 0x02, 0x0c1, 0xe2, 0x0c0 },
885 { 0x8c, 0x03, 0x040, 0x11, 0x849 },
886 { 0x8c, 0x03, 0x041, 0x31, 0x041 },
887 { 0x2b, 0x01, 0x014, 0x15, 0x015 },
888 { 0x2b, 0x01, 0x015, 0x95, 0x81d },
889 { 0xd0, 0x02, 0x0d0, 0x34, 0x8d8 },
890 { 0xd0, 0x02, 0x0d1, 0x74, 0x0d0 },
891 { 0x79, 0x04, 0x094, 0x27, 0x095 },
892 { 0x79, 0x04, 0x095, 0x37, 0x89d },
893 { 0x0e, 0x04, 0x0c0, 0xc0, 0x0c1 },
894 { 0x0e, 0x04, 0x0c1, 0xd0, 0x8c9 },
895 { 0xe7, 0x01, 0x094, 0x73, 0x89d },
896 { 0xe7, 0x01, 0x095, 0xf3, 0x095 },
897};
898
899const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU16 = 64;
900const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcr_intel_TestDataU16[64] =
901{
902 { 0x0000, 0x03, 0x044, 0x0000, 0x044 },
903 { 0x0000, 0x03, 0x045, 0x2000, 0x84c },
904 { 0xffff, 0x0a, 0x010, 0xffbf, 0x819 },
905 { 0xffff, 0x0a, 0x011, 0xffff, 0x011 },
906 { 0x0000, 0x08, 0x010, 0x0000, 0x010 },
907 { 0x0000, 0x08, 0x011, 0x0100, 0x818 },
908 { 0x0304, 0x0a, 0x054, 0x8200, 0x055 },
909 { 0x0304, 0x0a, 0x055, 0x8240, 0x85d },
910 { 0xf1a9, 0x07, 0x084, 0xa5e3, 0x88c },
911 { 0xf1a9, 0x07, 0x085, 0xa7e3, 0x084 },
912 { 0x21a3, 0x15, 0x0d4, 0x621a, 0x0d4 },
913 { 0x21a3, 0x15, 0x0d5, 0x721a, 0x8dc },
914 { 0x0289, 0x0d, 0x010, 0x2890, 0x010 },
915 { 0x0289, 0x0d, 0x011, 0x2898, 0x818 },
916 { 0x2a99, 0x1c, 0x094, 0xa645, 0x094 },
917 { 0x2a99, 0x1c, 0x095, 0xa665, 0x89c },
918 { 0x1812, 0x12, 0x014, 0x0c09, 0x014 },
919 { 0x1812, 0x12, 0x015, 0x8c09, 0x81c },
920 { 0x0131, 0x0d, 0x800, 0x1310, 0x000 },
921 { 0x0131, 0x0d, 0x801, 0x1318, 0x808 },
922 { 0x01c9, 0x0a, 0x880, 0xe480, 0x080 },
923 { 0x01c9, 0x0a, 0x881, 0xe4c0, 0x888 },
924 { 0xad21, 0x0e, 0x094, 0x690a, 0x89d },
925 { 0xad21, 0x0e, 0x095, 0x690e, 0x095 },
926 { 0x24a7, 0x0a, 0x010, 0x5389, 0x010 },
927 { 0x24a7, 0x0a, 0x011, 0x53c9, 0x818 },
928 { 0xca94, 0xd1, 0x090, 0xca94, 0x090 },
929 { 0xca94, 0xd1, 0x091, 0xca94, 0x091 },
930 { 0x991e, 0xf2, 0x810, 0x4c8f, 0x818 },
931 { 0x991e, 0xf2, 0x811, 0xcc8f, 0x010 },
932 { 0x003b, 0x1e, 0x000, 0x03b0, 0x000 },
933 { 0x003b, 0x1e, 0x001, 0x03b8, 0x808 },
934 { 0xf398, 0x15, 0x094, 0x0f39, 0x89d },
935 { 0xf398, 0x15, 0x095, 0x1f39, 0x095 },
936 { 0xf2d1, 0x00, 0x010, 0xf2d1, 0x010 },
937 { 0xf2d1, 0x00, 0x011, 0xf2d1, 0x011 },
938 { 0x071a, 0x01, 0x894, 0x038d, 0x094 },
939 { 0x071a, 0x01, 0x895, 0x838d, 0x89c },
940 { 0x82e2, 0x10, 0x050, 0x05c4, 0x859 },
941 { 0x82e2, 0x10, 0x051, 0x05c5, 0x051 },
942 { 0xe869, 0x11, 0x800, 0xe869, 0x808 },
943 { 0xe869, 0x11, 0x801, 0xe869, 0x809 },
944 { 0x6c3d, 0x11, 0x044, 0x6c3d, 0x044 },
945 { 0x6c3d, 0x11, 0x045, 0x6c3d, 0x045 },
946 { 0x89f1, 0x11, 0x040, 0x89f1, 0x040 },
947 { 0x89f1, 0x11, 0x041, 0x89f1, 0x041 },
948 { 0x1942, 0x11, 0x090, 0x1942, 0x090 },
949 { 0x1942, 0x11, 0x091, 0x1942, 0x091 },
950 { 0x03a4, 0x11, 0x010, 0x03a4, 0x010 },
951 { 0x03a4, 0x11, 0x011, 0x03a4, 0x011 },
952 { 0x30ff, 0x11, 0x004, 0x30ff, 0x004 },
953 { 0x30ff, 0x11, 0x005, 0x30ff, 0x005 },
954 { 0x475a, 0x11, 0x010, 0x475a, 0x010 },
955 { 0x475a, 0x11, 0x011, 0x475a, 0x011 },
956 { 0x001b, 0x00, 0x000, 0x001b, 0x000 },
957 { 0x001b, 0x00, 0x001, 0x001b, 0x001 },
958 { 0x13be, 0x11, 0x080, 0x13be, 0x080 },
959 { 0x13be, 0x11, 0x081, 0x13be, 0x081 },
960 { 0xcdca, 0x11, 0x850, 0xcdca, 0x858 },
961 { 0xcdca, 0x11, 0x851, 0xcdca, 0x859 },
962 { 0x003a, 0x11, 0x884, 0x003a, 0x88c },
963 { 0x003a, 0x11, 0x885, 0x003a, 0x88d },
964 { 0x5bb0, 0x11, 0x014, 0x5bb0, 0x014 },
965 { 0x5bb0, 0x11, 0x015, 0x5bb0, 0x015 },
966};
967
968const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU32 = 72;
969const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcr_intel_TestDataU32[72] =
970{
971 { 0x00000000, 0x02, 0x894, 0x00000000, 0x094 },
972 { 0x00000000, 0x02, 0x895, 0x40000000, 0x89c },
973 { 0xffffffff, 0x0b, 0x080, 0xffdfffff, 0x889 },
974 { 0xffffffff, 0x0b, 0x081, 0xffffffff, 0x081 },
975 { 0x00000000, 0x13, 0x084, 0x00000000, 0x084 },
976 { 0x00000000, 0x13, 0x085, 0x00002000, 0x88c },
977 { 0x00288037, 0x03, 0x050, 0xc0051006, 0x051 },
978 { 0x00288037, 0x03, 0x051, 0xe0051006, 0x859 },
979 { 0x5f76269f, 0xdc, 0x090, 0xeec4d3e5, 0x091 },
980 { 0x5f76269f, 0xdc, 0x091, 0xeec4d3f5, 0x899 },
981 { 0x60885325, 0x06, 0x054, 0x2982214c, 0x055 },
982 { 0x60885325, 0x06, 0x055, 0x2d82214c, 0x85d },
983 { 0x00002fb1, 0x0a, 0x0d4, 0xd880000b, 0x0d5 },
984 { 0x00002fb1, 0x0a, 0x0d5, 0xd8c0000b, 0x8dd },
985 { 0x9368422b, 0x1e, 0x884, 0x9b42115a, 0x88c },
986 { 0x9368422b, 0x1e, 0x885, 0x9b42115e, 0x084 },
987 { 0x2182904f, 0x19, 0x010, 0x82904f10, 0x011 },
988 { 0x2182904f, 0x19, 0x011, 0x82904f90, 0x819 },
989 { 0x0000f029, 0x0e, 0x014, 0x81480003, 0x015 },
990 { 0x0000f029, 0x0e, 0x015, 0x814c0003, 0x81d },
991 { 0x1f5427ea, 0x0b, 0x0d0, 0xfa83ea84, 0x0d1 },
992 { 0x1f5427ea, 0x0b, 0x0d1, 0xfaa3ea84, 0x8d9 },
993 { 0x2974f655, 0x09, 0x080, 0x5514ba7b, 0x080 },
994 { 0x2974f655, 0x09, 0x081, 0x5594ba7b, 0x888 },
995 { 0x00000efa, 0x1e, 0x004, 0x000077d0, 0x004 },
996 { 0x00000efa, 0x1e, 0x005, 0x000077d4, 0x80c },
997 { 0xadf20d85, 0x13, 0x0d4, 0x836155be, 0x8dc },
998 { 0xadf20d85, 0x13, 0x0d5, 0x836175be, 0x0d4 },
999 { 0xc00d49fb, 0x17, 0x080, 0x3527ed80, 0x888 },
1000 { 0xc00d49fb, 0x17, 0x081, 0x3527ef80, 0x080 },
1001 { 0x00000594, 0x0d, 0x890, 0x59400000, 0x090 },
1002 { 0x00000594, 0x0d, 0x891, 0x59480000, 0x898 },
1003 { 0xc12a0d3f, 0x05, 0x014, 0xf6095069, 0x81d },
1004 { 0xc12a0d3f, 0x05, 0x015, 0xfe095069, 0x015 },
1005 { 0x06d19a74, 0x1e, 0x090, 0x368cd3a0, 0x090 },
1006 { 0x06d19a74, 0x1e, 0x091, 0x368cd3a4, 0x898 },
1007 { 0x0003ec24, 0x3a, 0x094, 0x01f61200, 0x094 },
1008 { 0x0003ec24, 0x3a, 0x095, 0x01f61240, 0x89c },
1009 { 0x041f9055, 0x00, 0x014, 0x041f9055, 0x014 },
1010 { 0x041f9055, 0x00, 0x015, 0x041f9055, 0x015 },
1011 { 0x33f6e16b, 0x01, 0x050, 0x19fb70b5, 0x051 },
1012 { 0x33f6e16b, 0x01, 0x051, 0x99fb70b5, 0x859 },
1013 { 0x038e5dbd, 0x20, 0x094, 0x038e5dbd, 0x094 },
1014 { 0x038e5dbd, 0x20, 0x095, 0x038e5dbd, 0x095 },
1015 { 0xb4e0607b, 0x21, 0x800, 0x5a70303d, 0x809 },
1016 { 0xb4e0607b, 0x21, 0x801, 0xda70303d, 0x001 },
1017 { 0x92e594d0, 0x21, 0x0d4, 0x4972ca68, 0x8dc },
1018 { 0x92e594d0, 0x21, 0x0d5, 0xc972ca68, 0x0d4 },
1019 { 0x00003213, 0x21, 0x0c4, 0x00001909, 0x0c5 },
1020 { 0x00003213, 0x21, 0x0c5, 0x80001909, 0x8cd },
1021 { 0xd6374bf4, 0x21, 0x0c0, 0x6b1ba5fa, 0x8c8 },
1022 { 0xd6374bf4, 0x21, 0x0c1, 0xeb1ba5fa, 0x0c0 },
1023 { 0x181cabd9, 0x00, 0x090, 0x181cabd9, 0x090 },
1024 { 0x181cabd9, 0x00, 0x091, 0x181cabd9, 0x091 },
1025 { 0x0000fc63, 0x21, 0x010, 0x00007e31, 0x011 },
1026 { 0x0000fc63, 0x21, 0x011, 0x80007e31, 0x819 },
1027 { 0x34e58899, 0x21, 0x090, 0x1a72c44c, 0x091 },
1028 { 0x34e58899, 0x21, 0x091, 0x9a72c44c, 0x899 },
1029 { 0xfbaea3bb, 0x21, 0x0c0, 0x7dd751dd, 0x8c9 },
1030 { 0xfbaea3bb, 0x21, 0x0c1, 0xfdd751dd, 0x0c1 },
1031 { 0x0050c75c, 0x21, 0x080, 0x002863ae, 0x080 },
1032 { 0x0050c75c, 0x21, 0x081, 0x802863ae, 0x888 },
1033 { 0x0bd327a5, 0x21, 0x0d0, 0x05e993d2, 0x0d1 },
1034 { 0x0bd327a5, 0x21, 0x0d1, 0x85e993d2, 0x8d9 },
1035 { 0xd4dda2e0, 0x21, 0x094, 0x6a6ed170, 0x89c },
1036 { 0xd4dda2e0, 0x21, 0x095, 0xea6ed170, 0x094 },
1037 { 0x001129f1, 0x21, 0x080, 0x000894f8, 0x081 },
1038 { 0x001129f1, 0x21, 0x081, 0x800894f8, 0x889 },
1039 { 0x3ab4f893, 0x21, 0x0d4, 0x1d5a7c49, 0x0d5 },
1040 { 0x3ab4f893, 0x21, 0x0d5, 0x9d5a7c49, 0x8dd },
1041 { 0x48364778, 0x21, 0x094, 0x241b23bc, 0x094 },
1042 { 0x48364778, 0x21, 0x095, 0xa41b23bc, 0x89c },
1043};
Note: See TracBrowser for help on using the repository browser.

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