VirtualBox

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

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

ValKit/bs3-cpu-instr-2: Fixed problem in the generator for triggering OF with signed 8-bit and 32-bit immediate values. bugref:10376

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.4 KB
Line 
1/* $Id: bs3-cpu-instr-2-data16-intel.c16 104006 2024-03-22 23:09:25Z 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, 0x02, 0x0d4, 0x00, 0x044 },
44 { 0xff, 0x06, 0x011, 0xc0, 0x085 },
45 { 0x00, 0x07, 0x0d0, 0x00, 0x044 },
46 { 0xe4, 0x02, 0x010, 0x90, 0x085 },
47 { 0x79, 0x04, 0x010, 0x90, 0x88d },
48 { 0xc6, 0x00, 0x0d4, 0xc6, 0x0d4 },
49 { 0xc7, 0x0e, 0x054, 0x00, 0x044 },
50 { 0xc9, 0x01, 0x010, 0x92, 0x081 },
51 { 0x4b, 0x01, 0x084, 0x96, 0x88c },
52 { 0x11, 0x03, 0x010, 0x88, 0x084 },
53 { 0x80, 0x08, 0x094, 0x00, 0x84c },
54 { 0xbc, 0x06, 0x081, 0x00, 0x84d },
55 { 0x59, 0x0e, 0x050, 0x00, 0x84c },
56 { 0xb5, 0x00, 0x010, 0xb5, 0x010 },
57 { 0xcc, 0x06, 0x044, 0x00, 0x045 },
58 { 0x63, 0x00, 0x811, 0x63, 0x819 },
59 { 0xff, 0x09, 0x080, 0x00, 0x044 },
60 { 0xca, 0x03, 0x090, 0x50, 0x004 },
61 { 0x8e, 0x01, 0x880, 0x1c, 0x809 },
62 { 0xc1, 0x01, 0x0d4, 0x82, 0x085 },
63 { 0xdc, 0x00, 0x045, 0xdc, 0x045 },
64 { 0x98, 0x00, 0x0d4, 0x98, 0x0d4 },
65 { 0xdf, 0x03, 0x055, 0xf8, 0x080 },
66 { 0x79, 0x06, 0x054, 0x40, 0x808 },
67 { 0x6f, 0x0c, 0x090, 0x00, 0x84c },
68 { 0x98, 0x05, 0x004, 0x00, 0x84d },
69 { 0xfe, 0x0e, 0x084, 0x00, 0x044 },
70 { 0x6f, 0x07, 0x0c4, 0x80, 0x889 },
71 { 0xb8, 0x05, 0x0c1, 0x00, 0x84d },
72 { 0x75, 0x01, 0x0d4, 0xea, 0x888 },
73 { 0x28, 0x06, 0x840, 0x00, 0x044 },
74 { 0xd1, 0x07, 0x804, 0x80, 0x080 },
75};
76
77const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU16 = 32;
78const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shl_intel_TestDataU16[32] =
79{
80 { 0x0000, 0x01, 0x055, 0x0000, 0x044 },
81 { 0xffff, 0x01, 0x090, 0xfffe, 0x081 },
82 { 0x0000, 0x2c, 0x055, 0x0000, 0x044 },
83 { 0x0098, 0x09, 0x005, 0x3000, 0x005 },
84 { 0x9c87, 0x0c, 0x054, 0x7000, 0x80c },
85 { 0x85aa, 0x14, 0x040, 0x0000, 0x84c },
86 { 0x1441, 0x06, 0x005, 0x1040, 0x001 },
87 { 0xcf47, 0x0c, 0x084, 0x7000, 0x004 },
88 { 0xe7a8, 0x16, 0x094, 0x0000, 0x044 },
89 { 0x00d7, 0x01, 0x085, 0x01ae, 0x000 },
90 { 0x329e, 0x42, 0x0c5, 0xca78, 0x084 },
91 { 0xa025, 0x05, 0x090, 0x04a0, 0x80c },
92 { 0x004e, 0x0c, 0x891, 0xe000, 0x084 },
93 { 0x6b47, 0x0d, 0x0d5, 0xe000, 0x88c },
94 { 0x4a01, 0x07, 0x080, 0x0080, 0x809 },
95 { 0x01dd, 0x07, 0x011, 0xee80, 0x080 },
96 { 0x8050, 0x0c, 0x0c5, 0x0000, 0x84d },
97 { 0x6491, 0x00, 0x0c1, 0x6491, 0x0c1 },
98 { 0x00d6, 0x10, 0x051, 0x0000, 0x044 },
99 { 0x1121, 0x11, 0x011, 0x0000, 0x044 },
100 { 0x3934, 0x01, 0x0c5, 0x7268, 0x000 },
101 { 0x000a, 0x11, 0x855, 0x0000, 0x044 },
102 { 0x6450, 0x11, 0x014, 0x0000, 0x84c },
103 { 0xe40d, 0x11, 0x0d4, 0x0000, 0x044 },
104 { 0x38a5, 0x11, 0x091, 0x0000, 0x044 },
105 { 0x7cb5, 0x11, 0x011, 0x0000, 0x84c },
106 { 0x003f, 0x11, 0x014, 0x0000, 0x044 },
107 { 0x3b05, 0x00, 0x015, 0x3b05, 0x015 },
108 { 0x4840, 0x1b, 0x095, 0x0000, 0x84c },
109 { 0x7f8c, 0x0d, 0x055, 0x8000, 0x88d },
110 { 0x0006, 0x04, 0x0d5, 0x0060, 0x004 },
111 { 0x9a40, 0x2c, 0x090, 0x0000, 0x84c },
112};
113
114const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU32 = 36;
115const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shl_intel_TestDataU32[36] =
116{
117 { 0x00000000, 0x1d, 0x004, 0x00000000, 0x044 },
118 { 0xffffffff, 0x0b, 0x091, 0xfffff800, 0x085 },
119 { 0x00000000, 0x0d, 0x015, 0x00000000, 0x044 },
120 { 0x3757abf2, 0x14, 0x0c0, 0xbf200000, 0x084 },
121 { 0x55025998, 0x0e, 0x045, 0x96660000, 0x88c },
122 { 0x00009ada, 0x0d, 0x010, 0x135b4000, 0x004 },
123 { 0x98a2edfc, 0x1a, 0x0c0, 0xf0000000, 0x88d },
124 { 0xbc1e6dba, 0x3f, 0x0c0, 0x00000000, 0x84d },
125 { 0xf542e812, 0x0f, 0x0d4, 0x74090000, 0x005 },
126 { 0xa6bf6ae3, 0x08, 0x014, 0xbf6ae300, 0x88c },
127 { 0x00093e1e, 0x03, 0x051, 0x0049f0f0, 0x004 },
128 { 0x8c1088ae, 0x05, 0x085, 0x821115c0, 0x88d },
129 { 0x83b4505b, 0x16, 0x801, 0x16c00000, 0x80c },
130 { 0x8e0aa49f, 0x00, 0x8c5, 0x8e0aa49f, 0x8cd },
131 { 0x564156d8, 0x05, 0x084, 0xc82adb00, 0x88c },
132 { 0x0511fb61, 0x1d, 0x055, 0x20000000, 0x004 },
133 { 0xdaa8004a, 0x05, 0x0d0, 0x55000940, 0x001 },
134 { 0x32000d8d, 0x13, 0x054, 0x6c680000, 0x004 },
135 { 0x1114d8b4, 0x0e, 0x044, 0x362d0000, 0x005 },
136 { 0xf1d8c5f9, 0x01, 0x011, 0xe3b18bf2, 0x081 },
137 { 0x000007e8, 0x20, 0x0d5, 0x000007e8, 0x0d5 },
138 { 0x45ef42e4, 0x21, 0x001, 0x8bde85c8, 0x888 },
139 { 0x5e38d984, 0x21, 0x8c0, 0xbc71b308, 0x888 },
140 { 0xe487121d, 0x21, 0x001, 0xc90e243a, 0x085 },
141 { 0x555a6507, 0x21, 0x0c1, 0xaab4ca0e, 0x888 },
142 { 0x000000c7, 0x21, 0x0c1, 0x0000018e, 0x004 },
143 { 0x0c734a00, 0x21, 0x095, 0x18e69400, 0x004 },
144 { 0xe335e590, 0x21, 0x045, 0xc66bcb20, 0x081 },
145 { 0xf3d32043, 0x21, 0x004, 0xe7a64086, 0x081 },
146 { 0x5eb112d1, 0x21, 0x090, 0xbd6225a2, 0x888 },
147 { 0x00000020, 0x21, 0x0d0, 0x00000040, 0x000 },
148 { 0xe35e7064, 0x21, 0x085, 0xc6bce0c8, 0x081 },
149 { 0x470a7852, 0x21, 0x045, 0x8e14f0a4, 0x888 },
150 { 0x88a70a39, 0x21, 0x085, 0x114e1472, 0x80d },
151 { 0x761a7ee8, 0x21, 0x091, 0xec34fdd0, 0x888 },
152 { 0x00000a2d, 0x21, 0x094, 0x0000145a, 0x004 },
153};
154
155const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU8 = 32;
156const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shr_intel_TestDataU8[32] =
157{
158 { 0x00, 0x04, 0x040, 0x00, 0x044 },
159 { 0xff, 0x03, 0x0d0, 0x1f, 0x809 },
160 { 0x00, 0x02, 0x041, 0x00, 0x044 },
161 { 0x0f, 0x03, 0x095, 0x01, 0x001 },
162 { 0x92, 0x05, 0x090, 0x04, 0x809 },
163 { 0xf0, 0x01, 0x0c4, 0x78, 0x80c },
164 { 0xe4, 0x04, 0x010, 0x0e, 0x808 },
165 { 0x75, 0x03, 0x001, 0x0e, 0x001 },
166 { 0xff, 0x04, 0x041, 0x0f, 0x80d },
167 { 0xb7, 0x00, 0x0c0, 0xb7, 0x0c0 },
168 { 0x6c, 0x07, 0x095, 0x00, 0x045 },
169 { 0xcf, 0x03, 0x004, 0x19, 0x809 },
170 { 0xaf, 0x84, 0x0c4, 0x0a, 0x80d },
171 { 0xd5, 0x4d, 0x094, 0x00, 0x84c },
172 { 0x32, 0x07, 0x0c0, 0x00, 0x044 },
173 { 0xe1, 0x01, 0x084, 0x70, 0x809 },
174 { 0x47, 0x05, 0x080, 0x02, 0x000 },
175 { 0xa0, 0x08, 0x044, 0x00, 0x84d },
176 { 0x2c, 0x01, 0x0c0, 0x16, 0x000 },
177 { 0xdf, 0x09, 0x0d4, 0x00, 0x84c },
178 { 0xee, 0x09, 0x014, 0x00, 0x84c },
179 { 0x25, 0x01, 0x0d5, 0x12, 0x005 },
180 { 0x1c, 0x09, 0x0d4, 0x00, 0x044 },
181 { 0xdc, 0x09, 0x090, 0x00, 0x84c },
182 { 0xfe, 0x00, 0x884, 0xfe, 0x88c },
183 { 0x83, 0x09, 0x091, 0x00, 0x84c },
184 { 0x92, 0x01, 0x0c4, 0x49, 0x808 },
185 { 0x56, 0x00, 0x0d5, 0x56, 0x0d5 },
186 { 0x4b, 0x09, 0x0d0, 0x00, 0x044 },
187 { 0xa7, 0x09, 0x091, 0x00, 0x84c },
188 { 0x51, 0x09, 0x040, 0x00, 0x044 },
189 { 0x9e, 0x09, 0x045, 0x00, 0x84c },
190};
191
192const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU16 = 32;
193const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shr_intel_TestDataU16[32] =
194{
195 { 0x0000, 0x37, 0x040, 0x0000, 0x044 },
196 { 0xffff, 0x00, 0x015, 0xffff, 0x015 },
197 { 0x0000, 0x0e, 0x010, 0x0000, 0x044 },
198 { 0x00ba, 0x0b, 0x0c0, 0x0000, 0x044 },
199 { 0x86e8, 0x04, 0x010, 0x086e, 0x809 },
200 { 0x68bd, 0x15, 0x014, 0x0000, 0x044 },
201 { 0x00bd, 0x04, 0x811, 0x000b, 0x001 },
202 { 0x3081, 0x02, 0x041, 0x0c20, 0x000 },
203 { 0x57d6, 0x05, 0x011, 0x02be, 0x005 },
204 { 0x01b1, 0x00, 0x0c4, 0x01b1, 0x0c4 },
205 { 0xe901, 0x04, 0x054, 0x0e90, 0x80c },
206 { 0xb013, 0x17, 0x0d1, 0x0000, 0x84c },
207 { 0x00ba, 0x9a, 0x084, 0x0000, 0x044 },
208 { 0xf576, 0x09, 0x0c4, 0x007a, 0x809 },
209 { 0x032b, 0x19, 0x050, 0x0000, 0x044 },
210 { 0x0101, 0x0e, 0x0d0, 0x0000, 0x044 },
211 { 0x1b76, 0x0d, 0x801, 0x0000, 0x045 },
212 { 0xf452, 0x01, 0x050, 0x7a29, 0x808 },
213 { 0x001b, 0x10, 0x081, 0x0000, 0x044 },
214 { 0x5edb, 0x11, 0x880, 0x0000, 0x044 },
215 { 0x21da, 0x11, 0x841, 0x0000, 0x044 },
216 { 0x0030, 0x11, 0x0c4, 0x0000, 0x044 },
217 { 0xae3f, 0x11, 0x8c5, 0x0000, 0x84c },
218 { 0x7b55, 0x11, 0x0c1, 0x0000, 0x044 },
219 { 0x2b24, 0x11, 0x081, 0x0000, 0x044 },
220 { 0xae4a, 0x11, 0x004, 0x0000, 0x84c },
221 { 0x40dc, 0x00, 0x050, 0x40dc, 0x050 },
222 { 0x07ed, 0x11, 0x014, 0x0000, 0x044 },
223 { 0x008b, 0x11, 0x805, 0x0000, 0x044 },
224 { 0xa14d, 0x11, 0x801, 0x0000, 0x84c },
225 { 0x0061, 0x11, 0x010, 0x0000, 0x044 },
226 { 0xfaa9, 0x11, 0x091, 0x0000, 0x84c },
227};
228
229const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU32 = 36;
230const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shr_intel_TestDataU32[36] =
231{
232 { 0x00000000, 0x24, 0x005, 0x00000000, 0x044 },
233 { 0xffffffff, 0x18, 0x054, 0x000000ff, 0x80d },
234 { 0x00000000, 0x1b, 0x0c0, 0x00000000, 0x044 },
235 { 0x2f652c5b, 0x0c, 0x0d1, 0x0002f652, 0x001 },
236 { 0x1f6ca10d, 0x19, 0x0c4, 0x0000000f, 0x005 },
237 { 0x000003b4, 0x0b, 0x050, 0x00000000, 0x044 },
238 { 0x79b88dd4, 0xe7, 0x0d5, 0x00f3711b, 0x005 },
239 { 0xfae3e6df, 0x01, 0x081, 0x7d71f36f, 0x80d },
240 { 0x5090cbf5, 0x05, 0x081, 0x0284865f, 0x005 },
241 { 0xbcc8b373, 0x05, 0x811, 0x05e6459b, 0x809 },
242 { 0x000145d8, 0x35, 0x054, 0x00000000, 0x044 },
243 { 0x15ff0689, 0x1a, 0x850, 0x00000005, 0x004 },
244 { 0x4a7a41c4, 0x1b, 0x055, 0x00000009, 0x004 },
245 { 0x90d82967, 0x14, 0x054, 0x0000090d, 0x809 },
246 { 0x88679726, 0x2d, 0x804, 0x0004433c, 0x80d },
247 { 0x00000016, 0x0d, 0x015, 0x00000000, 0x044 },
248 { 0x68649bfe, 0x1d, 0x004, 0x00000003, 0x004 },
249 { 0xe78a241c, 0x08, 0x045, 0x00e78a24, 0x80c },
250 { 0x6849c20d, 0x18, 0x000, 0x00000068, 0x000 },
251 { 0x5afe30d6, 0x00, 0x054, 0x5afe30d6, 0x054 },
252 { 0x0007ed54, 0x20, 0x080, 0x0007ed54, 0x080 },
253 { 0x0205c653, 0x21, 0x091, 0x0102e329, 0x001 },
254 { 0x6f5cf282, 0x21, 0x0d5, 0x37ae7941, 0x004 },
255 { 0xc7cc6b58, 0x21, 0x040, 0x63e635ac, 0x80c },
256 { 0xe68e7550, 0x21, 0x005, 0x73473aa8, 0x808 },
257 { 0x00001564, 0x21, 0x005, 0x00000ab2, 0x004 },
258 { 0x79a5b597, 0x21, 0x041, 0x3cd2dacb, 0x001 },
259 { 0x4df861f2, 0x21, 0x081, 0x26fc30f9, 0x004 },
260 { 0x3841c9fd, 0x21, 0x090, 0x1c20e4fe, 0x001 },
261 { 0x42331b66, 0x21, 0x000, 0x21198db3, 0x000 },
262 { 0x000011b5, 0x21, 0x040, 0x000008da, 0x001 },
263 { 0xa46cf738, 0x21, 0x010, 0x52367b9c, 0x80c },
264 { 0x2b052cdb, 0x01, 0x0d1, 0x1582966d, 0x001 },
265 { 0xf2f09d32, 0x21, 0x014, 0x79784e99, 0x80c },
266 { 0xdcce6612, 0x21, 0x854, 0x6e673309, 0x80c },
267 { 0x0015dbcd, 0x21, 0x081, 0x000aede6, 0x001 },
268};
269
270const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU8 = 32;
271const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_sar_intel_TestDataU8[32] =
272{
273 { 0x00, 0x06, 0x0c0, 0x00, 0x044 },
274 { 0xff, 0x02, 0x005, 0xff, 0x085 },
275 { 0x00, 0x03, 0x010, 0x00, 0x044 },
276 { 0x81, 0x06, 0x044, 0xfe, 0x080 },
277 { 0x6b, 0x58, 0x081, 0x00, 0x044 },
278 { 0x6a, 0x02, 0x011, 0x1a, 0x001 },
279 { 0x5c, 0x07, 0x0d5, 0x00, 0x045 },
280 { 0x06, 0x06, 0x0c0, 0x00, 0x044 },
281 { 0x63, 0x00, 0x040, 0x63, 0x040 },
282 { 0x5c, 0x06, 0x090, 0x01, 0x000 },
283 { 0x48, 0x07, 0x055, 0x00, 0x045 },
284 { 0x51, 0x02, 0x050, 0x14, 0x004 },
285 { 0x46, 0x01, 0x010, 0x23, 0x000 },
286 { 0x4b, 0x0a, 0x051, 0x00, 0x044 },
287 { 0x94, 0x06, 0x854, 0xfe, 0x080 },
288 { 0x94, 0x08, 0x015, 0xff, 0x085 },
289 { 0x1b, 0x0f, 0x080, 0x00, 0x044 },
290 { 0x62, 0x09, 0x005, 0x00, 0x044 },
291 { 0x8c, 0x09, 0x084, 0xff, 0x085 },
292 { 0xbd, 0x09, 0x001, 0xff, 0x085 },
293 { 0x25, 0x09, 0x0c5, 0x00, 0x044 },
294 { 0xc1, 0x00, 0x884, 0xc1, 0x88c },
295 { 0x42, 0x06, 0x840, 0x01, 0x000 },
296 { 0xd1, 0x04, 0x080, 0xfd, 0x080 },
297 { 0x66, 0x01, 0x0d4, 0x33, 0x004 },
298 { 0x3c, 0x05, 0x0d4, 0x01, 0x001 },
299 { 0xf2, 0xe7, 0x010, 0xff, 0x085 },
300 { 0x51, 0x00, 0x015, 0x51, 0x015 },
301 { 0x9d, 0x0d, 0x081, 0xff, 0x085 },
302 { 0xdb, 0x01, 0x0c5, 0xed, 0x085 },
303 { 0x84, 0x58, 0x810, 0xff, 0x085 },
304 { 0x0d, 0x02, 0x0d0, 0x03, 0x004 },
305};
306
307const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU16 = 32;
308const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_sar_intel_TestDataU16[32] =
309{
310 { 0x0000, 0x04, 0x010, 0x0000, 0x044 },
311 { 0xffff, 0x08, 0x0c4, 0xffff, 0x085 },
312 { 0x0000, 0x13, 0x0d1, 0x0000, 0x044 },
313 { 0x02b3, 0x08, 0x0d1, 0x0002, 0x001 },
314 { 0x1279, 0x19, 0x055, 0x0000, 0x044 },
315 { 0x6ee1, 0x15, 0x0c0, 0x0000, 0x044 },
316 { 0x1243, 0x0a, 0x011, 0x0004, 0x001 },
317 { 0x13cf, 0x14, 0x090, 0x0000, 0x044 },
318 { 0x07c0, 0x1f, 0x890, 0x0000, 0x044 },
319 { 0x0066, 0x08, 0x0c1, 0x0000, 0x044 },
320 { 0x1034, 0x0a, 0x094, 0x0004, 0x000 },
321 { 0x6f36, 0x02, 0x054, 0x1bcd, 0x001 },
322 { 0x0017, 0x08, 0x0d5, 0x0000, 0x044 },
323 { 0x6384, 0x18, 0x080, 0x0000, 0x044 },
324 { 0x7788, 0x84, 0x094, 0x0778, 0x005 },
325 { 0x07d7, 0x0a, 0x0d4, 0x0001, 0x001 },
326 { 0xdb91, 0x0a, 0x0d0, 0xfff6, 0x085 },
327 { 0x6e2c, 0x00, 0x0c0, 0x6e2c, 0x0c0 },
328 { 0x02fa, 0x01, 0x044, 0x017d, 0x004 },
329 { 0x3cf0, 0x10, 0x091, 0x0000, 0x044 },
330 { 0x144d, 0x11, 0x0c5, 0x0000, 0x044 },
331 { 0x7292, 0x00, 0x811, 0x7292, 0x819 },
332 { 0x49f7, 0x07, 0x085, 0x0093, 0x005 },
333 { 0xca99, 0x0c, 0x0d5, 0xfffc, 0x085 },
334 { 0x001a, 0x1f, 0x015, 0x0000, 0x044 },
335 { 0x1f50, 0x42, 0x084, 0x07d4, 0x004 },
336 { 0xf184, 0x0a, 0x084, 0xfffc, 0x084 },
337 { 0x00d8, 0x12, 0x000, 0x0000, 0x044 },
338 { 0xbeb4, 0x09, 0x0c5, 0xffdf, 0x080 },
339 { 0xda8a, 0x05, 0x090, 0xfed4, 0x084 },
340 { 0x03d0, 0x06, 0x840, 0x000f, 0x004 },
341 { 0x28b7, 0x04, 0x801, 0x028b, 0x004 },
342};
343
344const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU32 = 36;
345const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_sar_intel_TestDataU32[36] =
346{
347 { 0x00000000, 0x1e, 0x0c0, 0x00000000, 0x044 },
348 { 0xffffffff, 0x13, 0x090, 0xffffffff, 0x085 },
349 { 0x00000000, 0xe7, 0x891, 0x00000000, 0x044 },
350 { 0x6df75da9, 0x09, 0x0c0, 0x0036fbae, 0x001 },
351 { 0x7a8b6453, 0x2c, 0x040, 0x0007a8b6, 0x000 },
352 { 0x031b51bf, 0x3d, 0x005, 0x00000000, 0x044 },
353 { 0x21a2c383, 0x15, 0x845, 0x0000010d, 0x000 },
354 { 0xda6314cc, 0x10, 0x0c5, 0xffffda63, 0x084 },
355 { 0x1215b43b, 0x17, 0x044, 0x00000024, 0x004 },
356 { 0x1db07b0f, 0x16, 0x0d1, 0x00000076, 0x001 },
357 { 0x004c60ae, 0x1e, 0x0c4, 0x00000000, 0x044 },
358 { 0xf6dd7ddf, 0x1d, 0x051, 0xffffffff, 0x085 },
359 { 0x162f5f2f, 0x0a, 0x091, 0x00058bd7, 0x005 },
360 { 0x5d779fe9, 0x0f, 0x051, 0x0000baef, 0x000 },
361 { 0x9005efae, 0x19, 0x001, 0xffffffc8, 0x080 },
362 { 0x00000511, 0x0f, 0x000, 0x00000000, 0x044 },
363 { 0x531bb829, 0x0c, 0x084, 0x000531bb, 0x005 },
364 { 0x65f9dc4e, 0x0f, 0x095, 0x0000cbf3, 0x005 },
365 { 0x199fe046, 0x3e, 0x004, 0x00000000, 0x044 },
366 { 0x495749b3, 0x00, 0x0c4, 0x495749b3, 0x0c4 },
367 { 0x00000129, 0x01, 0x0c5, 0x00000094, 0x001 },
368 { 0x3279bfbd, 0x20, 0x0d4, 0x3279bfbd, 0x0d4 },
369 { 0x5ca117a9, 0x21, 0x000, 0x2e508bd4, 0x005 },
370 { 0xdfe380f8, 0x21, 0x0c4, 0xeff1c07c, 0x080 },
371 { 0x1c3b2bb1, 0x21, 0x090, 0x0e1d95d8, 0x005 },
372 { 0x73f2d6ed, 0x00, 0x855, 0x73f2d6ed, 0x85d },
373 { 0x5beb176c, 0x19, 0x814, 0x0000002d, 0x005 },
374 { 0x61aba258, 0x00, 0x050, 0x61aba258, 0x050 },
375 { 0xb2449da0, 0x1b, 0x005, 0xfffffff6, 0x084 },
376 { 0x39c88b3f, 0x8f, 0x091, 0x00007391, 0x000 },
377 { 0x0003ec96, 0x15, 0x094, 0x00000000, 0x044 },
378 { 0x76681f6c, 0x1b, 0x0d5, 0x0000000e, 0x001 },
379 { 0x72af5c72, 0x1d, 0x0c1, 0x00000003, 0x005 },
380 { 0xc48c351f, 0x0c, 0x891, 0xfffc48c3, 0x084 },
381 { 0x05d9a7ef, 0x09, 0x011, 0x0002ecd3, 0x001 },
382 { 0x0e3ea7a4, 0x0a, 0x055, 0x00038fa9, 0x005 },
383};
384
385const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU8 = 32;
386const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rol_intel_TestDataU8[32] =
387{
388 { 0x00, 0x8f, 0x001, 0x00, 0x000 },
389 { 0xff, 0x07, 0x004, 0xff, 0x005 },
390 { 0x00, 0x03, 0x890, 0x00, 0x098 }, /* OF/Ib */
391 { 0xc2, 0x07, 0x0d4, 0x61, 0x0d5 },
392 { 0x4d, 0x02, 0x040, 0x35, 0x841 }, /* OF/Ib */
393 { 0x70, 0xbb, 0x091, 0x83, 0x891 }, /* OF/Ib */
394 { 0x7b, 0x06, 0x085, 0xde, 0x884 }, /* OF/Ib */
395 { 0x7c, 0x00, 0x0c4, 0x7c, 0x0c4 },
396 { 0x46, 0x08, 0x014, 0x46, 0x814 }, /* OF/Ib */
397 { 0xc9, 0x03, 0x001, 0x4e, 0x000 },
398 { 0x81, 0x0c, 0x0c4, 0x18, 0x8c4 }, /* OF/Ib */
399 { 0x72, 0x05, 0x095, 0x4e, 0x894 }, /* OF/Ib */
400 { 0x9d, 0x02, 0x050, 0x76, 0x850 }, /* OF/Ib */
401 { 0x12, 0x0b, 0x090, 0x90, 0x090 },
402 { 0x52, 0x01, 0x044, 0xa4, 0x84c },
403 { 0xd9, 0x05, 0x095, 0x3b, 0x095 },
404 { 0xc2, 0x07, 0x011, 0x61, 0x011 },
405 { 0xd7, 0x09, 0x0c5, 0xaf, 0x0c5 },
406 { 0x68, 0x01, 0x0d4, 0xd0, 0x8dc },
407 { 0x25, 0x01, 0x0c0, 0x4a, 0x0c0 },
408 { 0x6d, 0x09, 0x055, 0xda, 0x854 }, /* OF/Ib */
409 { 0xc8, 0x09, 0x044, 0x91, 0x045 },
410 { 0xfe, 0x09, 0x011, 0xfd, 0x011 },
411 { 0xd9, 0x09, 0x044, 0xb3, 0x045 },
412 { 0x29, 0x09, 0x014, 0x52, 0x014 },
413 { 0xd3, 0x09, 0x004, 0xa7, 0x005 },
414 { 0x35, 0x09, 0x0c4, 0x6a, 0x0c4 },
415 { 0xbf, 0x09, 0x085, 0x7f, 0x885 }, /* OF/Ib */
416 { 0xc5, 0x09, 0x081, 0x8b, 0x081 },
417 { 0xba, 0x09, 0x094, 0x75, 0x895 }, /* OF/Ib */
418 { 0x18, 0x00, 0x0c0, 0x18, 0x0c0 },
419 { 0xf1, 0x09, 0x095, 0xe3, 0x095 },
420}; /* Note! 8-bit rol reg,imm8 results differed 11 times from the other form */
421
422const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU16 = 32;
423const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rol_intel_TestDataU16[32] =
424{
425 { 0x0000, 0x2c, 0x011, 0x0000, 0x010 },
426 { 0xffff, 0x0b, 0x085, 0xffff, 0x085 },
427 { 0x0000, 0x00, 0x091, 0x0000, 0x091 },
428 { 0x0004, 0x01, 0x084, 0x0008, 0x084 },
429 { 0xb5ee, 0x07, 0x085, 0xf75a, 0x884 }, /* OF/Ib */
430 { 0xf8d8, 0x01, 0x090, 0xf1b1, 0x091 },
431 { 0x01dd, 0x0b, 0x095, 0xe80e, 0x094 },
432 { 0xebe1, 0x2c, 0x014, 0x1ebe, 0x014 },
433 { 0x9bf1, 0x1a, 0x011, 0xc66f, 0x811 }, /* OF/Ib */
434 { 0x006a, 0x07, 0x004, 0x3500, 0x004 },
435 { 0x12d1, 0x03, 0x0c0, 0x9688, 0x0c0 },
436 { 0x6a71, 0x0b, 0x091, 0x8b53, 0x891 }, /* OF/Ib */
437 { 0x001e, 0x0c, 0x050, 0xe001, 0x051 },
438 { 0x6b19, 0x0c, 0x0d5, 0x96b1, 0x8d5 }, /* OF/Ib */
439 { 0x2f52, 0x1b, 0x0c5, 0x917a, 0x0c4 },
440 { 0x17b8, 0x16, 0x0d4, 0xee05, 0x0d5 },
441 { 0xda84, 0x12, 0x010, 0x6a13, 0x011 },
442 { 0x20bc, 0x10, 0x085, 0x20bc, 0x084 },
443 { 0x003d, 0x11, 0x050, 0x007a, 0x050 },
444 { 0x48b4, 0x11, 0x0d1, 0x9168, 0x8d0 }, /* OF/Ib */
445 { 0x0bc1, 0x11, 0x050, 0x1782, 0x050 },
446 { 0x01b8, 0x11, 0x084, 0x0370, 0x084 },
447 { 0x9b67, 0x11, 0x054, 0x36cf, 0x855 }, /* OF/Ib */
448 { 0xa3ba, 0x11, 0x054, 0x4775, 0x855 }, /* OF/Ib */
449 { 0x0007, 0x11, 0x094, 0x000e, 0x094 },
450 { 0xb545, 0x11, 0x055, 0x6a8b, 0x855 }, /* OF/Ib */
451 { 0x55c5, 0x11, 0x080, 0xab8a, 0x880 }, /* OF/Ib */
452 { 0x0013, 0x11, 0x055, 0x0026, 0x054 },
453 { 0x42a6, 0x11, 0x040, 0x854c, 0x840 }, /* OF/Ib */
454 { 0x57c4, 0x11, 0x091, 0xaf88, 0x890 }, /* OF/Ib */
455 { 0x03fd, 0x11, 0x000, 0x07fa, 0x000 },
456 { 0x3c54, 0x11, 0x080, 0x78a8, 0x080 },
457}; /* Note! 16-bit rol reg,imm8 results differed 11 times from the other form */
458
459const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU32 = 36;
460const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rol_intel_TestDataU32[36] =
461{
462 { 0x00000000, 0x02, 0x040, 0x00000000, 0x040 },
463 { 0xffffffff, 0x2f, 0x015, 0xffffffff, 0x015 },
464 { 0x00000000, 0x0f, 0x014, 0x00000000, 0x014 },
465 { 0x136ef312, 0x09, 0x084, 0xdde62426, 0x084 },
466 { 0x454511da, 0x09, 0x094, 0x8a23b48a, 0x894 }, /* OF/Ib */
467 { 0x00000606, 0x0e, 0x084, 0x01818000, 0x084 },
468 { 0x77af735a, 0x05, 0x010, 0xf5ee6b4e, 0x810 }, /* OF/Ib */
469 { 0xf4a2bdd6, 0x2c, 0x081, 0x2bdd6f4a, 0x080 },
470 { 0x419a1ef3, 0x17, 0x051, 0x79a0cd0f, 0x851 }, /* OF/Ib */
471 { 0xa95a63b3, 0x1a, 0x004, 0xcea5698e, 0x804 }, /* OF/Ib */
472 { 0x0007324a, 0x00, 0x0d0, 0x0007324a, 0x0d0 },
473 { 0xee027162, 0x07, 0x055, 0x0138b177, 0x055 },
474 { 0x5411cebb, 0x08, 0x015, 0x11cebb54, 0x814 }, /* OF/Ib */
475 { 0x30d5081e, 0x11, 0x080, 0x103c61aa, 0x080 },
476 { 0xa8bbb874, 0x10, 0x040, 0xb874a8bb, 0x841 }, /* OF/Ib */
477 { 0x00245fee, 0x05, 0x041, 0x048bfdc0, 0x040 },
478 { 0x57281a0c, 0x34, 0x090, 0xa0c57281, 0x891 }, /* OF/Ib */
479 { 0x8291724f, 0x0d, 0x045, 0x2e49f052, 0x844 }, /* OF/Ib */
480 { 0x6edc9488, 0x01, 0x005, 0xddb92910, 0x80c },
481 { 0x3d65f552, 0x20, 0x894, 0x3d65f552, 0x89c },
482 { 0x001d229f, 0x21, 0x001, 0x003a453e, 0x000 },
483 { 0x5597eb30, 0x21, 0x054, 0xab2fd660, 0x85c },
484 { 0x0f6b886f, 0x21, 0x040, 0x1ed710de, 0x040 },
485 { 0xc4d100fa, 0x21, 0x000, 0x89a201f5, 0x001 },
486 { 0xb82b75f5, 0x21, 0x000, 0x7056ebeb, 0x809 },
487 { 0x00000085, 0x21, 0x041, 0x0000010a, 0x040 },
488 { 0x1189ae0d, 0x21, 0x041, 0x23135c1a, 0x040 },
489 { 0x3730b214, 0x21, 0x050, 0x6e616428, 0x050 },
490 { 0xb5ec1aa8, 0x21, 0x080, 0x6bd83551, 0x889 },
491 { 0xbe3dc331, 0x21, 0x801, 0x7c7b8663, 0x809 },
492 { 0x00005dd1, 0x21, 0x010, 0x0000bba2, 0x010 },
493 { 0xc2473fc9, 0x21, 0x055, 0x848e7f93, 0x055 },
494 { 0xb830eaed, 0x00, 0x015, 0xb830eaed, 0x015 },
495 { 0xe98a8754, 0x21, 0x054, 0xd3150ea9, 0x055 },
496 { 0x16247e46, 0x21, 0x094, 0x2c48fc8c, 0x094 },
497 { 0x00000269, 0x21, 0x010, 0x000004d2, 0x010 },
498}; /* Note! 32-bit rol reg,imm8 results differed 8 times from the other form */
499
500const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU8 = 32;
501const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_ror_intel_TestDataU8[32] =
502{
503 { 0x00, 0x0e, 0x091, 0x00, 0x090 },
504 { 0xff, 0x05, 0x055, 0xff, 0x055 },
505 { 0x00, 0x02, 0x094, 0x00, 0x094 },
506 { 0x93, 0x02, 0x0d4, 0xe4, 0x0d5 },
507 { 0x84, 0x01, 0x894, 0x42, 0x89c },
508 { 0x27, 0x07, 0x044, 0x4e, 0x844 }, /* OF/Ib */
509 { 0x11, 0x07, 0x011, 0x22, 0x810 }, /* OF/Ib */
510 { 0xd6, 0x06, 0x081, 0x5b, 0x880 }, /* OF/Ib */
511 { 0xbb, 0x04, 0x014, 0xbb, 0x015 },
512 { 0x97, 0x06, 0x000, 0x5e, 0x000 },
513 { 0x53, 0x02, 0x085, 0xd4, 0x885 }, /* OF/Ib */
514 { 0xf4, 0x04, 0x881, 0x4f, 0x888 },
515 { 0x15, 0x02, 0x015, 0x45, 0x814 }, /* OF/Ib */
516 { 0x6c, 0x00, 0x045, 0x6c, 0x045 },
517 { 0x7f, 0x01, 0x0c4, 0xbf, 0x8cd },
518 { 0x53, 0x02, 0x805, 0xd4, 0x80d },
519 { 0x36, 0x01, 0x004, 0x1b, 0x004 },
520 { 0x31, 0x08, 0x044, 0x31, 0x844 }, /* OF/Ib */
521 { 0x05, 0x09, 0x054, 0x82, 0x855 }, /* OF/Ib */
522 { 0x97, 0x09, 0x810, 0xcb, 0x019 }, /* OF/Ib */
523 { 0x52, 0x09, 0x045, 0x29, 0x044 },
524 { 0x50, 0x09, 0x041, 0x28, 0x040 },
525 { 0x8d, 0x09, 0x010, 0xc6, 0x011 },
526 { 0x47, 0x09, 0x085, 0xa3, 0x885 }, /* OF/Ib */
527 { 0x85, 0x09, 0x0d5, 0xc2, 0x0d5 },
528 { 0x78, 0x09, 0x044, 0x3c, 0x044 },
529 { 0x72, 0x00, 0x085, 0x72, 0x085 },
530 { 0x69, 0x09, 0x090, 0xb4, 0x891 }, /* OF/Ib */
531 { 0x8e, 0x09, 0x0d5, 0x47, 0x8d4 }, /* OF/Ib */
532 { 0x9c, 0x09, 0x041, 0x4e, 0x840 }, /* OF/Ib */
533 { 0xdb, 0x09, 0x010, 0xed, 0x011 },
534 { 0xcf, 0x09, 0x044, 0xe7, 0x045 },
535}; /* Note! 8-bit ror reg,imm8 results differed 12 times from the other form */
536
537const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU16 = 32;
538const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_ror_intel_TestDataU16[32] =
539{
540 { 0x0000, 0x0d, 0x084, 0x0000, 0x084 },
541 { 0xffff, 0x04, 0x051, 0xffff, 0x051 },
542 { 0x0000, 0x09, 0x015, 0x0000, 0x014 },
543 { 0x0009, 0x0d, 0x055, 0x0048, 0x854 }, /* OF/Ib */
544 { 0xc375, 0x04, 0x040, 0x5c37, 0x040 },
545 { 0x64e7, 0x0a, 0x054, 0x39d9, 0x854 }, /* OF/Ib */
546 { 0x0254, 0x0d, 0x045, 0x12a0, 0x044 },
547 { 0xd180, 0x0a, 0x015, 0x6034, 0x814 }, /* OF/Ib */
548 { 0x6a2e, 0x07, 0x045, 0x5cd4, 0x044 },
549 { 0x00e0, 0x06, 0x894, 0x8003, 0x09d }, /* OF/Ib */
550 { 0x112d, 0x00, 0x845, 0x112d, 0x84d },
551 { 0xf427, 0x1f, 0x0d0, 0xe84f, 0x0d1 },
552 { 0x0051, 0x02, 0x084, 0x4014, 0x884 }, /* OF/Ib */
553 { 0xc97f, 0x08, 0x084, 0x7fc9, 0x084 },
554 { 0x62e5, 0x05, 0x054, 0x2b17, 0x854 }, /* OF/Ib */
555 { 0x0017, 0x00, 0x091, 0x0017, 0x091 },
556 { 0x2a08, 0x12, 0x0c5, 0x0a82, 0x0c4 },
557 { 0x4589, 0x01, 0x044, 0xa2c4, 0x84d },
558 { 0x0061, 0x10, 0x090, 0x0061, 0x890 }, /* OF/Ib */
559 { 0xd193, 0x11, 0x080, 0xe8c9, 0x081 },
560 { 0xae20, 0x11, 0x050, 0x5710, 0x850 }, /* OF/Ib */
561 { 0x15ab, 0x11, 0x044, 0x8ad5, 0x845 }, /* OF/Ib */
562 { 0x1013, 0x11, 0x014, 0x8809, 0x815 }, /* OF/Ib */
563 { 0x45c2, 0x11, 0x044, 0x22e1, 0x044 },
564 { 0x01da, 0x11, 0x051, 0x00ed, 0x050 },
565 { 0x64b3, 0x11, 0x015, 0xb259, 0x815 }, /* OF/Ib */
566 { 0x2b67, 0x11, 0x000, 0x95b3, 0x801 }, /* OF/Ib */
567 { 0x0596, 0x11, 0x080, 0x02cb, 0x080 },
568 { 0x3a6e, 0x0a, 0x041, 0x9b8e, 0x041 },
569 { 0x89f8, 0x1f, 0x854, 0x13f1, 0x85c },
570 { 0x0005, 0x12, 0x0c5, 0x4001, 0x8c4 }, /* OF/Ib */
571 { 0x7b34, 0x19, 0x010, 0x9a3d, 0x011 },
572}; /* Note! 16-bit ror reg,imm8 results differed 13 times from the other form */
573
574const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU32 = 36;
575const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_ror_intel_TestDataU32[36] =
576{
577 { 0x00000000, 0x36, 0x081, 0x00000000, 0x080 },
578 { 0xffffffff, 0x1f, 0x090, 0xffffffff, 0x091 },
579 { 0x00000000, 0x03, 0x090, 0x00000000, 0x090 },
580 { 0x8e1411d2, 0x0a, 0x854, 0x74a38504, 0x85c },
581 { 0xe3194a80, 0x14, 0x004, 0x94a80e31, 0x805 }, /* OF/Ib */
582 { 0x0000d9f0, 0x15, 0x0d5, 0x06cf8000, 0x0d4 },
583 { 0x1dd35912, 0x0a, 0x0c5, 0x448774d6, 0x0c4 },
584 { 0x8a65e77f, 0x01, 0x044, 0xc532f3bf, 0x045 },
585 { 0x5beabe6e, 0xe7, 0x0c5, 0xdcb7d57c, 0x0c5 },
586 { 0x880347cc, 0x03, 0x000, 0x910068f9, 0x801 }, /* OF/Ib */
587 { 0x0000037c, 0x1b, 0x0d0, 0x00006f80, 0x0d0 },
588 { 0x46f703fb, 0x03, 0x014, 0x68dee07f, 0x814 }, /* OF/Ib */
589 { 0x4c1b1bbb, 0x06, 0x000, 0xed306c6e, 0x801 }, /* OF/Ib */
590 { 0xe5caafd6, 0x0f, 0x0d4, 0x5fadcb95, 0x8d4 }, /* OF/Ib */
591 { 0x75d6e983, 0x12, 0x010, 0xba60dd75, 0x811 }, /* OF/Ib */
592 { 0x0884fc51, 0x05, 0x084, 0x884427e2, 0x885 }, /* OF/Ib */
593 { 0x022d0690, 0x0d, 0x015, 0x34801168, 0x014 },
594 { 0x8b28344b, 0x79, 0x081, 0x941a25c5, 0x081 },
595 { 0xf29db7c3, 0x1e, 0x0c1, 0xca76df0f, 0x0c1 },
596 { 0x72278a60, 0x00, 0x854, 0x72278a60, 0x85c },
597 { 0x01349536, 0x20, 0x081, 0x01349536, 0x081 },
598 { 0xb95cd06c, 0x21, 0x084, 0x5cae6836, 0x88c },
599 { 0xa4412805, 0x21, 0x050, 0xd2209402, 0x051 },
600 { 0x19162c5d, 0x21, 0x0c0, 0x8c8b162e, 0x8c9 },
601 { 0x9309b7ae, 0x21, 0x0c5, 0x4984dbd7, 0x8cc },
602 { 0x00002569, 0x21, 0x895, 0x800012b4, 0x89d },
603 { 0xa2638e78, 0x21, 0x811, 0x5131c73c, 0x818 },
604 { 0x7be06757, 0x21, 0x081, 0xbdf033ab, 0x889 },
605 { 0x63711c5c, 0x21, 0x004, 0x31b88e2e, 0x004 },
606 { 0xaa7a8ad3, 0x21, 0x081, 0xd53d4569, 0x081 },
607 { 0x0021ccec, 0x21, 0x051, 0x0010e676, 0x050 },
608 { 0x7d878a26, 0x21, 0x091, 0x3ec3c513, 0x090 },
609 { 0xb5276a6c, 0x21, 0x041, 0x5a93b536, 0x848 },
610 { 0x75a371eb, 0x21, 0x001, 0xbad1b8f5, 0x809 },
611 { 0x7f9a01be, 0x21, 0x0d0, 0x3fcd00df, 0x0d0 },
612 { 0x001575dd, 0x21, 0x081, 0x800abaee, 0x889 },
613}; /* Note! 32-bit ror reg,imm8 results differed 7 times from the other form */
614
615const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU8 = 64;
616const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcl_intel_TestDataU8[64] =
617{
618 { 0x00, 0x0f, 0x040, 0x00, 0x040 },
619 { 0x00, 0x0f, 0x041, 0x20, 0x040 },
620 { 0xff, 0x02, 0x894, 0xfd, 0x095 },
621 { 0xff, 0x02, 0x895, 0xff, 0x095 },
622 { 0x00, 0x01, 0x044, 0x00, 0x044 },
623 { 0x00, 0x01, 0x045, 0x01, 0x044 },
624 { 0xbc, 0x06, 0x090, 0x17, 0x899 },
625 { 0xbc, 0x06, 0x091, 0x37, 0x899 },
626 { 0x5d, 0x07, 0x004, 0x97, 0x80c },
627 { 0x5d, 0x07, 0x005, 0xd7, 0x80c },
628 { 0x53, 0x07, 0x090, 0x94, 0x899 },
629 { 0x53, 0x07, 0x091, 0xd4, 0x899 },
630 { 0xdf, 0x06, 0x094, 0xdb, 0x095 },
631 { 0xdf, 0x06, 0x095, 0xfb, 0x095 },
632 { 0x06, 0x04, 0x0d0, 0x60, 0x0d0 },
633 { 0x06, 0x04, 0x0d1, 0x68, 0x0d0 },
634 { 0xac, 0x06, 0x850, 0x15, 0x859 },
635 { 0xac, 0x06, 0x851, 0x35, 0x859 },
636 { 0x71, 0x06, 0x090, 0x4e, 0x898 },
637 { 0x71, 0x06, 0x091, 0x6e, 0x898 },
638 { 0xbd, 0x05, 0x084, 0xab, 0x88d },
639 { 0xbd, 0x05, 0x085, 0xbb, 0x88d },
640 { 0xf2, 0x01, 0x080, 0xe4, 0x081 },
641 { 0xf2, 0x01, 0x081, 0xe5, 0x081 },
642 { 0xc5, 0x01, 0x004, 0x8a, 0x005 },
643 { 0xc5, 0x01, 0x005, 0x8b, 0x005 },
644 { 0x16, 0x00, 0x090, 0x16, 0x090 },
645 { 0x16, 0x00, 0x091, 0x16, 0x091 },
646 { 0x86, 0x0f, 0x090, 0x90, 0x899 },
647 { 0x86, 0x0f, 0x091, 0xb0, 0x899 },
648 { 0xf7, 0x0a, 0x0c0, 0xee, 0x0c1 },
649 { 0xf7, 0x0a, 0x0c1, 0xef, 0x0c1 },
650 { 0x8c, 0x02, 0x044, 0x31, 0x84c },
651 { 0x8c, 0x02, 0x045, 0x33, 0x84c },
652 { 0x6c, 0x08, 0x884, 0x36, 0x88c },
653 { 0x6c, 0x08, 0x885, 0xb6, 0x88c },
654 { 0x43, 0x09, 0x010, 0x43, 0x010 },
655 { 0x43, 0x09, 0x011, 0x43, 0x011 },
656 { 0x9d, 0x09, 0x054, 0x9d, 0x054 },
657 { 0x9d, 0x09, 0x055, 0x9d, 0x055 },
658 { 0xb0, 0x09, 0x010, 0xb0, 0x010 },
659 { 0xb0, 0x09, 0x011, 0xb0, 0x011 },
660 { 0xb5, 0x00, 0x0c4, 0xb5, 0x0c4 },
661 { 0xb5, 0x00, 0x0c5, 0xb5, 0x0c5 },
662 { 0x0f, 0x09, 0x0d0, 0x0f, 0x0d0 },
663 { 0x0f, 0x09, 0x0d1, 0x0f, 0x0d1 },
664 { 0xf7, 0x01, 0x0d4, 0xee, 0x0d5 },
665 { 0xf7, 0x01, 0x0d5, 0xef, 0x0d5 },
666 { 0xbd, 0x09, 0x0c0, 0xbd, 0x0c0 },
667 { 0xbd, 0x09, 0x0c1, 0xbd, 0x0c1 },
668 { 0xca, 0x09, 0x040, 0xca, 0x040 },
669 { 0xca, 0x09, 0x041, 0xca, 0x041 },
670 { 0x2f, 0x09, 0x080, 0x2f, 0x080 },
671 { 0x2f, 0x09, 0x081, 0x2f, 0x081 },
672 { 0xc3, 0x09, 0x014, 0xc3, 0x014 },
673 { 0xc3, 0x09, 0x015, 0xc3, 0x015 },
674 { 0x6a, 0x09, 0x000, 0x6a, 0x000 },
675 { 0x6a, 0x09, 0x001, 0x6a, 0x001 },
676 { 0xcc, 0x09, 0x010, 0xcc, 0x010 },
677 { 0xcc, 0x09, 0x011, 0xcc, 0x011 },
678 { 0xe9, 0x09, 0x804, 0xe9, 0x80c },
679 { 0xe9, 0x09, 0x805, 0xe9, 0x80d },
680 { 0x6b, 0x00, 0x040, 0x6b, 0x040 },
681 { 0x6b, 0x00, 0x041, 0x6b, 0x041 },
682};
683
684const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU16 = 64;
685const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcl_intel_TestDataU16[64] =
686{
687 { 0x0000, 0x58, 0x0d0, 0x0000, 0x0d0 },
688 { 0x0000, 0x58, 0x0d1, 0x0040, 0x0d0 },
689 { 0xffff, 0x0e, 0x014, 0xdfff, 0x015 },
690 { 0xffff, 0x0e, 0x015, 0xffff, 0x015 },
691 { 0x0000, 0x0d, 0x054, 0x0000, 0x054 },
692 { 0x0000, 0x0d, 0x055, 0x1000, 0x054 },
693 { 0x01a2, 0x08, 0x090, 0xa200, 0x091 },
694 { 0x01a2, 0x08, 0x091, 0xa280, 0x091 },
695 { 0x023e, 0x00, 0x014, 0x023e, 0x014 },
696 { 0x023e, 0x00, 0x015, 0x023e, 0x015 },
697 { 0x36eb, 0x0f, 0x040, 0x8dba, 0x041 },
698 { 0x36eb, 0x0f, 0x041, 0xcdba, 0x041 },
699 { 0x00cf, 0x02, 0x890, 0x033c, 0x090 },
700 { 0x00cf, 0x02, 0x891, 0x033e, 0x090 },
701 { 0x6856, 0x04, 0x054, 0x8563, 0x85c },
702 { 0x6856, 0x04, 0x055, 0x856b, 0x85c },
703 { 0xbcb3, 0x0a, 0x040, 0xcd79, 0x848 },
704 { 0xbcb3, 0x0a, 0x041, 0xcf79, 0x848 },
705 { 0x003a, 0x0c, 0x010, 0xa001, 0x011 },
706 { 0x003a, 0x0c, 0x011, 0xa801, 0x011 },
707 { 0x31c4, 0x1c, 0x004, 0x20c7, 0x004 },
708 { 0x31c4, 0x1c, 0x005, 0x24c7, 0x004 },
709 { 0xc854, 0x04, 0x010, 0x8546, 0x010 },
710 { 0xc854, 0x04, 0x011, 0x854e, 0x010 },
711 { 0x0243, 0x58, 0x010, 0x2180, 0x011 },
712 { 0x0243, 0x58, 0x011, 0x21c0, 0x011 },
713 { 0xb9d1, 0x0f, 0x884, 0xae74, 0x88c },
714 { 0xb9d1, 0x0f, 0x885, 0xee74, 0x88c },
715 { 0x6270, 0x18, 0x000, 0x3818, 0x809 },
716 { 0x6270, 0x18, 0x001, 0x3858, 0x809 },
717 { 0x3494, 0x03, 0x000, 0xa4a0, 0x001 },
718 { 0x3494, 0x03, 0x001, 0xa4a4, 0x001 },
719 { 0x6034, 0x07, 0x0c0, 0x1a18, 0x8c8 },
720 { 0x6034, 0x07, 0x0c1, 0x1a58, 0x8c8 },
721 { 0xaa86, 0x01, 0x0d0, 0x550c, 0x8d9 },
722 { 0xaa86, 0x01, 0x0d1, 0x550d, 0x8d9 },
723 { 0x12a2, 0x01, 0x040, 0x2544, 0x040 },
724 { 0x12a2, 0x01, 0x041, 0x2545, 0x040 },
725 { 0xf781, 0x10, 0x014, 0x7bc0, 0x015 },
726 { 0xf781, 0x10, 0x015, 0xfbc0, 0x015 },
727 { 0x2bb3, 0x11, 0x0c4, 0x2bb3, 0x0c4 },
728 { 0x2bb3, 0x11, 0x0c5, 0x2bb3, 0x0c5 },
729 { 0x016f, 0x11, 0x014, 0x016f, 0x014 },
730 { 0x016f, 0x11, 0x015, 0x016f, 0x015 },
731 { 0xa1e9, 0x11, 0x840, 0xa1e9, 0x848 },
732 { 0xa1e9, 0x11, 0x841, 0xa1e9, 0x849 },
733 { 0x0a1f, 0x11, 0x800, 0x0a1f, 0x808 },
734 { 0x0a1f, 0x11, 0x801, 0x0a1f, 0x809 },
735 { 0x0015, 0x11, 0x850, 0x0015, 0x858 },
736 { 0x0015, 0x11, 0x851, 0x0015, 0x859 },
737 { 0x1ebc, 0x11, 0x0c0, 0x1ebc, 0x0c0 },
738 { 0x1ebc, 0x11, 0x0c1, 0x1ebc, 0x0c1 },
739 { 0x4d38, 0x11, 0x004, 0x4d38, 0x004 },
740 { 0x4d38, 0x11, 0x005, 0x4d38, 0x005 },
741 { 0x1fb3, 0x11, 0x050, 0x1fb3, 0x050 },
742 { 0x1fb3, 0x11, 0x051, 0x1fb3, 0x051 },
743 { 0x0607, 0x11, 0x044, 0x0607, 0x044 },
744 { 0x0607, 0x11, 0x045, 0x0607, 0x045 },
745 { 0x901a, 0x11, 0x044, 0x901a, 0x044 },
746 { 0x901a, 0x11, 0x045, 0x901a, 0x045 },
747 { 0x1c73, 0x11, 0x000, 0x1c73, 0x000 },
748 { 0x1c73, 0x11, 0x001, 0x1c73, 0x001 },
749 { 0x9dd9, 0x11, 0x0c0, 0x9dd9, 0x0c0 },
750 { 0x9dd9, 0x11, 0x0c1, 0x9dd9, 0x0c1 },
751};
752
753const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU32 = 72;
754const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcl_intel_TestDataU32[72] =
755{
756 { 0x00000000, 0x3f, 0x080, 0x00000000, 0x080 },
757 { 0x00000000, 0x3f, 0x081, 0x40000000, 0x080 },
758 { 0xffffffff, 0x16, 0x014, 0xffdfffff, 0x015 },
759 { 0xffffffff, 0x16, 0x015, 0xffffffff, 0x015 },
760 { 0x00000000, 0x0e, 0x010, 0x00000000, 0x010 },
761 { 0x00000000, 0x0e, 0x011, 0x00002000, 0x010 },
762 { 0xad1acf63, 0x37, 0x004, 0xb1ab46b3, 0x80d },
763 { 0xad1acf63, 0x37, 0x005, 0xb1eb46b3, 0x80d },
764 { 0x80ea23b2, 0x29, 0x844, 0xd4476480, 0x84d },
765 { 0x80ea23b2, 0x29, 0x845, 0xd4476580, 0x84d },
766 { 0x0eb61ca2, 0x0d, 0x000, 0xc39440eb, 0x000 },
767 { 0x0eb61ca2, 0x0d, 0x001, 0xc39450eb, 0x000 },
768 { 0xc6e2a573, 0x0d, 0x014, 0x54ae6c6e, 0x014 },
769 { 0xc6e2a573, 0x0d, 0x015, 0x54ae7c6e, 0x014 },
770 { 0xc7b05fe6, 0x1b, 0x014, 0x331ec17f, 0x015 },
771 { 0xc7b05fe6, 0x1b, 0x015, 0x371ec17f, 0x015 },
772 { 0xd829226d, 0x12, 0x054, 0x89b5b052, 0x054 },
773 { 0xd829226d, 0x12, 0x055, 0x89b7b052, 0x054 },
774 { 0x9c87c613, 0x07, 0x090, 0x43e309a7, 0x898 },
775 { 0x9c87c613, 0x07, 0x091, 0x43e309e7, 0x898 },
776 { 0x00000192, 0x01, 0x040, 0x00000324, 0x040 },
777 { 0x00000192, 0x01, 0x041, 0x00000325, 0x040 },
778 { 0xb4244475, 0x11, 0x080, 0x88eab424, 0x888 },
779 { 0xb4244475, 0x11, 0x081, 0x88ebb424, 0x888 },
780 { 0x47c5a8c8, 0x14, 0x044, 0x8c823e2d, 0x84c },
781 { 0x47c5a8c8, 0x14, 0x045, 0x8c8a3e2d, 0x84c },
782 { 0x10c9d734, 0x09, 0x004, 0x93ae6810, 0x005 },
783 { 0x10c9d734, 0x09, 0x005, 0x93ae6910, 0x005 },
784 { 0x2eaaf30e, 0x11, 0x094, 0xe61c2eaa, 0x095 },
785 { 0x2eaaf30e, 0x11, 0x095, 0xe61d2eaa, 0x095 },
786 { 0x00000099, 0x14, 0x050, 0x09900000, 0x050 },
787 { 0x00000099, 0x14, 0x051, 0x09980000, 0x050 },
788 { 0x4886e1f6, 0x0d, 0x080, 0xdc3ec488, 0x888 },
789 { 0x4886e1f6, 0x0d, 0x081, 0xdc3ed488, 0x888 },
790 { 0x17ce0dc6, 0x1f, 0x010, 0x05f38371, 0x011 },
791 { 0x17ce0dc6, 0x1f, 0x011, 0x45f38371, 0x011 },
792 { 0xc97167e7, 0x1c, 0x894, 0x764b8b3f, 0x094 },
793 { 0xc97167e7, 0x1c, 0x895, 0x7e4b8b3f, 0x094 },
794 { 0xd08fb80c, 0x00, 0x0d4, 0xd08fb80c, 0x0d4 },
795 { 0xd08fb80c, 0x00, 0x0d5, 0xd08fb80c, 0x0d5 },
796 { 0x0000062a, 0x01, 0x050, 0x00000c54, 0x050 },
797 { 0x0000062a, 0x01, 0x051, 0x00000c55, 0x050 },
798 { 0xd25d66d9, 0x20, 0x040, 0xd25d66d9, 0x040 },
799 { 0xd25d66d9, 0x20, 0x041, 0xd25d66d9, 0x041 },
800 { 0x05456169, 0x21, 0x054, 0x0a8ac2d2, 0x054 },
801 { 0x05456169, 0x21, 0x055, 0x0a8ac2d3, 0x054 },
802 { 0xcba88dcc, 0x21, 0x0c4, 0x97511b98, 0x0c5 },
803 { 0xcba88dcc, 0x21, 0x0c5, 0x97511b99, 0x0c5 },
804 { 0xc6c866fe, 0x21, 0x090, 0x8d90cdfc, 0x091 },
805 { 0xc6c866fe, 0x21, 0x091, 0x8d90cdfd, 0x091 },
806 { 0x0007345d, 0x21, 0x004, 0x000e68ba, 0x004 },
807 { 0x0007345d, 0x21, 0x005, 0x000e68bb, 0x004 },
808 { 0x597f7a89, 0x21, 0x000, 0xb2fef512, 0x808 },
809 { 0x597f7a89, 0x21, 0x001, 0xb2fef513, 0x808 },
810 { 0xbef1f324, 0x21, 0x010, 0x7de3e648, 0x819 },
811 { 0xbef1f324, 0x21, 0x011, 0x7de3e649, 0x819 },
812 { 0xa8bf12c8, 0x21, 0x000, 0x517e2590, 0x809 },
813 { 0xa8bf12c8, 0x21, 0x001, 0x517e2591, 0x809 },
814 { 0x66b2e83d, 0x21, 0x090, 0xcd65d07a, 0x898 },
815 { 0x66b2e83d, 0x21, 0x091, 0xcd65d07b, 0x898 },
816 { 0x000009fc, 0x21, 0x054, 0x000013f8, 0x054 },
817 { 0x000009fc, 0x21, 0x055, 0x000013f9, 0x054 },
818 { 0x9fcba1f3, 0x21, 0x8d0, 0x3f9743e6, 0x8d9 },
819 { 0x9fcba1f3, 0x21, 0x8d1, 0x3f9743e7, 0x8d9 },
820 { 0xf182baef, 0x21, 0x014, 0xe30575de, 0x015 },
821 { 0xf182baef, 0x21, 0x015, 0xe30575df, 0x015 },
822 { 0xa7e6237b, 0x21, 0x884, 0x4fcc46f6, 0x88d },
823 { 0xa7e6237b, 0x21, 0x885, 0x4fcc46f7, 0x88d },
824 { 0x4cfd92c7, 0x21, 0x054, 0x99fb258e, 0x85c },
825 { 0x4cfd92c7, 0x21, 0x055, 0x99fb258f, 0x85c },
826 { 0x00000ef5, 0x21, 0x014, 0x00001dea, 0x014 },
827 { 0x00000ef5, 0x21, 0x015, 0x00001deb, 0x014 },
828};
829
830const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU8 = 64;
831const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcr_intel_TestDataU8[64] =
832{
833 { 0x00, 0x00, 0x0c4, 0x00, 0x0c4 },
834 { 0x00, 0x00, 0x0c5, 0x00, 0x0c5 },
835 { 0xff, 0x03, 0x010, 0xdf, 0x819 },
836 { 0xff, 0x03, 0x011, 0xff, 0x011 },
837 { 0x00, 0x09, 0x050, 0x00, 0x050 },
838 { 0x00, 0x09, 0x051, 0x00, 0x051 },
839 { 0x7f, 0x00, 0x080, 0x7f, 0x080 },
840 { 0x7f, 0x00, 0x081, 0x7f, 0x081 },
841 { 0xbe, 0x06, 0x014, 0xf2, 0x81d },
842 { 0xbe, 0x06, 0x015, 0xf6, 0x015 },
843 { 0xd5, 0x00, 0x8d0, 0xd5, 0x8d8 },
844 { 0xd5, 0x00, 0x8d1, 0xd5, 0x8d9 },
845 { 0xf3, 0x58, 0x044, 0x9b, 0x84d },
846 { 0xf3, 0x58, 0x045, 0x9f, 0x045 },
847 { 0xdc, 0x00, 0x094, 0xdc, 0x094 },
848 { 0xdc, 0x00, 0x095, 0xdc, 0x095 },
849 { 0x27, 0x6e, 0x040, 0x71, 0x040 },
850 { 0x27, 0x6e, 0x041, 0x79, 0x848 },
851 { 0xa3, 0x06, 0x880, 0x1a, 0x889 },
852 { 0xa3, 0x06, 0x881, 0x1e, 0x081 },
853 { 0x67, 0x0e, 0x000, 0x73, 0x000 },
854 { 0x67, 0x0e, 0x001, 0x7b, 0x808 },
855 { 0xb3, 0x04, 0x090, 0x6b, 0x898 },
856 { 0xb3, 0x04, 0x091, 0x7b, 0x090 },
857 { 0xe9, 0x03, 0x004, 0x5d, 0x80c },
858 { 0xe9, 0x03, 0x005, 0x7d, 0x004 },
859 { 0x11, 0x07, 0x014, 0x44, 0x014 },
860 { 0x11, 0x07, 0x015, 0x46, 0x81c },
861 { 0x4b, 0x02, 0x080, 0x92, 0x081 },
862 { 0x4b, 0x02, 0x081, 0xd2, 0x889 },
863 { 0x4e, 0x04, 0x044, 0xc4, 0x045 },
864 { 0x4e, 0x04, 0x045, 0xd4, 0x84d },
865 { 0xad, 0x0b, 0x050, 0xab, 0x858 },
866 { 0xad, 0x0b, 0x051, 0xeb, 0x050 },
867 { 0xa1, 0x01, 0x084, 0x50, 0x88d },
868 { 0xa1, 0x01, 0x085, 0xd0, 0x085 },
869 { 0xb5, 0x01, 0x0d4, 0x5a, 0x8dd },
870 { 0xb5, 0x01, 0x0d5, 0xda, 0x0d5 },
871 { 0x24, 0x08, 0x090, 0x48, 0x090 },
872 { 0x24, 0x08, 0x091, 0x49, 0x898 },
873 { 0xa2, 0x04, 0x080, 0x4a, 0x888 },
874 { 0xa2, 0x04, 0x081, 0x5a, 0x080 },
875 { 0x9b, 0x00, 0x0d4, 0x9b, 0x0d4 },
876 { 0x9b, 0x00, 0x0d5, 0x9b, 0x0d5 },
877 { 0x5c, 0xa5, 0x814, 0xc2, 0x015 },
878 { 0x5c, 0xa5, 0x815, 0xca, 0x81d },
879 { 0x2f, 0x63, 0x0c0, 0xc5, 0x0c1 },
880 { 0x2f, 0x63, 0x0c1, 0xe5, 0x8c9 },
881 { 0xae, 0x01, 0x054, 0x57, 0x85c },
882 { 0xae, 0x01, 0x055, 0xd7, 0x054 },
883 { 0xdd, 0x0b, 0x0c4, 0xb7, 0x8cc },
884 { 0xdd, 0x0b, 0x0c5, 0xf7, 0x0c4 },
885 { 0xda, 0x05, 0x090, 0xa6, 0x899 },
886 { 0xda, 0x05, 0x091, 0xae, 0x091 },
887 { 0xf8, 0x07, 0x040, 0xe1, 0x849 },
888 { 0xf8, 0x07, 0x041, 0xe3, 0x041 },
889 { 0x66, 0x03, 0x014, 0x8c, 0x015 },
890 { 0x66, 0x03, 0x015, 0xac, 0x81d },
891 { 0xa9, 0x07, 0x010, 0xa5, 0x818 },
892 { 0xa9, 0x07, 0x011, 0xa7, 0x010 },
893 { 0x97, 0x84, 0x090, 0xe9, 0x898 },
894 { 0x97, 0x84, 0x091, 0xf9, 0x090 },
895 { 0xf6, 0x05, 0x084, 0x67, 0x88d },
896 { 0xf6, 0x05, 0x085, 0x6f, 0x085 },
897};
898
899const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU16 = 64;
900const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcr_intel_TestDataU16[64] =
901{
902 { 0x0000, 0x06, 0x050, 0x0000, 0x050 },
903 { 0x0000, 0x06, 0x051, 0x0400, 0x858 },
904 { 0xffff, 0x58, 0x0d0, 0xfdff, 0x8d9 },
905 { 0xffff, 0x58, 0x0d1, 0xffff, 0x0d1 },
906 { 0x0000, 0x03, 0x0d0, 0x0000, 0x0d0 },
907 { 0x0000, 0x03, 0x0d1, 0x2000, 0x8d8 },
908 { 0x07f6, 0x00, 0x0c4, 0x07f6, 0x0c4 },
909 { 0x07f6, 0x00, 0x0c5, 0x07f6, 0x0c5 },
910 { 0x77a1, 0x0c, 0x0c0, 0xf427, 0x0c0 },
911 { 0x77a1, 0x0c, 0x0c1, 0xf437, 0x8c8 },
912 { 0xfb73, 0x04, 0x004, 0x6fb7, 0x80c },
913 { 0xfb73, 0x04, 0x005, 0x7fb7, 0x004 },
914 { 0x01e2, 0x0a, 0x000, 0xf100, 0x000 },
915 { 0x01e2, 0x0a, 0x001, 0xf140, 0x808 },
916 { 0x1a08, 0x10, 0x050, 0x3410, 0x050 },
917 { 0x1a08, 0x10, 0x051, 0x3411, 0x858 },
918 { 0x7289, 0x14, 0x054, 0x4e51, 0x054 },
919 { 0x7289, 0x14, 0x055, 0x6e51, 0x85c },
920 { 0x0016, 0x08, 0x004, 0x2c00, 0x004 },
921 { 0x0016, 0x08, 0x005, 0x2d00, 0x80c },
922 { 0x7ca0, 0x1e, 0x040, 0xca03, 0x041 },
923 { 0x7ca0, 0x1e, 0x041, 0xca0b, 0x849 },
924 { 0x81f2, 0x0b, 0x000, 0x7c90, 0x808 },
925 { 0x81f2, 0x0b, 0x001, 0x7cb0, 0x000 },
926 { 0x0b83, 0x07, 0x084, 0x0c17, 0x084 },
927 { 0x0b83, 0x07, 0x085, 0x0e17, 0x88c },
928 { 0xa107, 0x02, 0x8c4, 0xa841, 0x8cd },
929 { 0xa107, 0x02, 0x8c5, 0xe841, 0x0c5 },
930 { 0x0e57, 0x01, 0x0d0, 0x072b, 0x0d1 },
931 { 0x0e57, 0x01, 0x0d1, 0x872b, 0x8d9 },
932 { 0x0016, 0x0c, 0x000, 0x02c0, 0x000 },
933 { 0x0016, 0x0c, 0x001, 0x02d0, 0x808 },
934 { 0xe12b, 0x11, 0x054, 0xe12b, 0x054 },
935 { 0xe12b, 0x11, 0x055, 0xe12b, 0x055 },
936 { 0xd45c, 0xc6, 0x004, 0xe351, 0x80c },
937 { 0xd45c, 0xc6, 0x005, 0xe751, 0x004 },
938 { 0x0123, 0x0e, 0x094, 0x0918, 0x094 },
939 { 0x0123, 0x0e, 0x095, 0x091c, 0x89c },
940 { 0xbffd, 0x05, 0x044, 0xd5ff, 0x84d },
941 { 0xbffd, 0x05, 0x045, 0xddff, 0x045 },
942 { 0xb6d0, 0x02, 0x090, 0x2db4, 0x898 },
943 { 0xb6d0, 0x02, 0x091, 0x6db4, 0x090 },
944 { 0x4b76, 0x01, 0x014, 0x25bb, 0x014 },
945 { 0x4b76, 0x01, 0x015, 0xa5bb, 0x81c },
946 { 0xb1a8, 0x04, 0x0c4, 0x0b1a, 0x8cd },
947 { 0xb1a8, 0x04, 0x0c5, 0x1b1a, 0x0c5 },
948 { 0xdf1e, 0x04, 0x814, 0xcdf1, 0x81d },
949 { 0xdf1e, 0x04, 0x815, 0xddf1, 0x015 },
950 { 0x093c, 0x0d, 0x0d0, 0x93c0, 0x0d0 },
951 { 0x093c, 0x0d, 0x0d1, 0x93c8, 0x8d8 },
952 { 0xcce8, 0x00, 0x004, 0xcce8, 0x004 },
953 { 0xcce8, 0x00, 0x005, 0xcce8, 0x005 },
954 { 0x8396, 0x84, 0x080, 0xc839, 0x888 },
955 { 0x8396, 0x84, 0x081, 0xd839, 0x080 },
956 { 0x208d, 0x0a, 0x050, 0x4688, 0x050 },
957 { 0x208d, 0x0a, 0x051, 0x46c8, 0x858 },
958 { 0xdf2b, 0x0a, 0x010, 0x95b7, 0x819 },
959 { 0xdf2b, 0x0a, 0x011, 0x95f7, 0x011 },
960 { 0xb887, 0x02, 0x0d4, 0xae21, 0x8dd },
961 { 0xb887, 0x02, 0x0d5, 0xee21, 0x0d5 },
962 { 0x0352, 0x1a, 0x800, 0x5201, 0x001 },
963 { 0x0352, 0x1a, 0x801, 0x5281, 0x809 },
964 { 0x631e, 0x42, 0x050, 0x18c7, 0x051 },
965 { 0x631e, 0x42, 0x051, 0x58c7, 0x859 },
966};
967
968const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU32 = 72;
969const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcr_intel_TestDataU32[72] =
970{
971 { 0x00000000, 0x11, 0x084, 0x00000000, 0x084 },
972 { 0x00000000, 0x11, 0x085, 0x00008000, 0x88c },
973 { 0xffffffff, 0x84, 0x044, 0xefffffff, 0x84d },
974 { 0xffffffff, 0x84, 0x045, 0xffffffff, 0x045 },
975 { 0x00000000, 0x05, 0x8c4, 0x00000000, 0x0c4 },
976 { 0x00000000, 0x05, 0x8c5, 0x08000000, 0x8cc },
977 { 0x9622e89f, 0x13, 0x894, 0xba27d2c4, 0x89c },
978 { 0x9622e89f, 0x13, 0x895, 0xba27f2c4, 0x094 },
979 { 0x3244f50b, 0x15, 0x0c0, 0x4f50b192, 0x0c0 },
980 { 0x3244f50b, 0x15, 0x0c1, 0x4f50b992, 0x8c8 },
981 { 0x00021120, 0x1b, 0x054, 0x00844800, 0x054 },
982 { 0x00021120, 0x1b, 0x055, 0x00844820, 0x85c },
983 { 0x77af458f, 0x18, 0x004, 0x5e8b1e77, 0x005 },
984 { 0x77af458f, 0x18, 0x005, 0x5e8b1f77, 0x80d },
985 { 0xf99a6629, 0x1e, 0x844, 0xccd3314b, 0x84d },
986 { 0xf99a6629, 0x1e, 0x845, 0xccd3314f, 0x045 },
987 { 0x53b57054, 0xe7, 0x094, 0x50a76ae0, 0x095 },
988 { 0x53b57054, 0xe7, 0x095, 0x52a76ae0, 0x89d },
989 { 0x77350376, 0x1e, 0x044, 0xb9a81bb1, 0x045 },
990 { 0x77350376, 0x1e, 0x045, 0xb9a81bb5, 0x84d },
991 { 0x00000b38, 0x15, 0x0c0, 0x00b38000, 0x0c0 },
992 { 0x00000b38, 0x15, 0x0c1, 0x00b38800, 0x8c8 },
993 { 0xd79008d3, 0x0e, 0x040, 0x469b5e40, 0x848 },
994 { 0xd79008d3, 0x0e, 0x041, 0x469f5e40, 0x040 },
995 { 0xf003eba4, 0x1c, 0x010, 0x007d748f, 0x818 },
996 { 0xf003eba4, 0x1c, 0x011, 0x007d749f, 0x010 },
997 { 0x6c28c530, 0x09, 0x054, 0x30361462, 0x055 },
998 { 0x6c28c530, 0x09, 0x055, 0x30b61462, 0x85d },
999 { 0xda152dec, 0x08, 0x0d4, 0xd8da152d, 0x8dd },
1000 { 0xda152dec, 0x08, 0x0d5, 0xd9da152d, 0x0d5 },
1001 { 0x000d9c09, 0x1f, 0x094, 0x00367024, 0x094 },
1002 { 0x000d9c09, 0x1f, 0x095, 0x00367026, 0x89c },
1003 { 0xb3308ea2, 0x0f, 0x014, 0x3a896661, 0x81c },
1004 { 0xb3308ea2, 0x0f, 0x015, 0x3a8b6661, 0x014 },
1005 { 0xe0799ed7, 0x1c, 0x054, 0x0f33daee, 0x85c },
1006 { 0xe0799ed7, 0x1c, 0x055, 0x0f33dafe, 0x054 },
1007 { 0xb266bf88, 0x2f, 0x0d4, 0xfe2164cd, 0x8dc },
1008 { 0xb266bf88, 0x2f, 0x0d5, 0xfe2364cd, 0x0d4 },
1009 { 0x85762b44, 0x00, 0x0d0, 0x85762b44, 0x0d0 },
1010 { 0x85762b44, 0x00, 0x0d1, 0x85762b44, 0x0d1 },
1011 { 0x00008e60, 0x01, 0x090, 0x00004730, 0x090 },
1012 { 0x00008e60, 0x01, 0x091, 0x80004730, 0x898 },
1013 { 0x184a001d, 0x20, 0x000, 0x184a001d, 0x000 },
1014 { 0x184a001d, 0x20, 0x001, 0x184a001d, 0x001 },
1015 { 0xd5e2ef43, 0x21, 0x094, 0x6af177a1, 0x89d },
1016 { 0xd5e2ef43, 0x21, 0x095, 0xeaf177a1, 0x095 },
1017 { 0x2fe845aa, 0x21, 0x040, 0x17f422d5, 0x040 },
1018 { 0x2fe845aa, 0x21, 0x041, 0x97f422d5, 0x848 },
1019 { 0x9b6a381e, 0x21, 0x010, 0x4db51c0f, 0x818 },
1020 { 0x9b6a381e, 0x21, 0x011, 0xcdb51c0f, 0x010 },
1021 { 0x00320b3d, 0x21, 0x0d4, 0x0019059e, 0x0d5 },
1022 { 0x00320b3d, 0x21, 0x0d5, 0x8019059e, 0x8dd },
1023 { 0x9da2f01b, 0x21, 0x0d0, 0x4ed1780d, 0x8d9 },
1024 { 0x9da2f01b, 0x21, 0x0d1, 0xced1780d, 0x0d1 },
1025 { 0x627d3c5c, 0x21, 0x054, 0x313e9e2e, 0x054 },
1026 { 0x627d3c5c, 0x21, 0x055, 0xb13e9e2e, 0x85c },
1027 { 0x50e53b4d, 0x21, 0x0c4, 0x28729da6, 0x0c5 },
1028 { 0x50e53b4d, 0x21, 0x0c5, 0xa8729da6, 0x8cd },
1029 { 0x26f62b4a, 0x01, 0x0d0, 0x137b15a5, 0x0d0 },
1030 { 0x26f62b4a, 0x01, 0x0d1, 0x937b15a5, 0x8d8 },
1031 { 0x0000198e, 0x21, 0x0c4, 0x00000cc7, 0x0c4 },
1032 { 0x0000198e, 0x21, 0x0c5, 0x80000cc7, 0x8cc },
1033 { 0x41fecd90, 0x21, 0x0d0, 0x20ff66c8, 0x0d0 },
1034 { 0x41fecd90, 0x21, 0x0d1, 0xa0ff66c8, 0x8d8 },
1035 { 0x568af637, 0x21, 0x0d4, 0x2b457b1b, 0x0d5 },
1036 { 0x568af637, 0x21, 0x0d5, 0xab457b1b, 0x8dd },
1037 { 0xdbed10d2, 0x21, 0x014, 0x6df68869, 0x81c },
1038 { 0xdbed10d2, 0x21, 0x015, 0xedf68869, 0x014 },
1039 { 0xce783943, 0x21, 0x000, 0x673c1ca1, 0x809 },
1040 { 0xce783943, 0x21, 0x001, 0xe73c1ca1, 0x001 },
1041 { 0x00050066, 0x21, 0x0c4, 0x00028033, 0x0c4 },
1042 { 0x00050066, 0x21, 0x0c5, 0x80028033, 0x8cc },
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