VirtualBox

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

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

ValKit/bs3-cpu-instr-2: AMD test data. bugref:10376

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 39.4 KB
Line 
1/* $Id: bs3-cpu-instr-2-data16-amd.c16 104007 2024-03-22 23:42:08Z vboxsync $ */
2/** @file
3 * BS3Kit - bs3-cpu-instr-2, bs3-cpu-instr-2-data16-amd.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_amd_TestDataU8 = 28;
41const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shl_amd_TestDataU8[28] =
42{
43 { 0x00, 0x00, 0x015, 0x00, 0x015 },
44 { 0xff, 0x08, 0x0c1, 0x00, 0x85d },
45 { 0x00, 0x01, 0x015, 0x00, 0x054 },
46 { 0xba, 0x08, 0x0d1, 0x00, 0x054 },
47 { 0xca, 0x02, 0x081, 0x28, 0x81d },
48 { 0x70, 0x0b, 0x055, 0x00, 0x054 },
49 { 0x7c, 0x07, 0x0c1, 0x00, 0x054 },
50 { 0x4e, 0x0f, 0x050, 0x00, 0x054 },
51 { 0x69, 0x04, 0x084, 0x90, 0x89c },
52 { 0x93, 0x00, 0x054, 0x93, 0x054 },
53 { 0xe4, 0x00, 0x0d4, 0xe4, 0x0d4 },
54 { 0xe8, 0x07, 0x000, 0x00, 0x054 },
55 { 0xd7, 0x06, 0x0c5, 0xc0, 0x095 },
56 { 0x58, 0x04, 0x0d0, 0x80, 0x091 },
57 { 0x6e, 0x05, 0x015, 0xc0, 0x095 },
58 { 0x2f, 0x09, 0x055, 0x00, 0x054 },
59 { 0xce, 0x09, 0x050, 0x00, 0x054 },
60 { 0xd8, 0x09, 0x890, 0x00, 0x054 },
61 { 0x53, 0x09, 0x011, 0x00, 0x054 },
62 { 0xef, 0x09, 0x004, 0x00, 0x054 },
63 { 0x9b, 0x09, 0x011, 0x00, 0x054 },
64 { 0x15, 0x09, 0x081, 0x00, 0x054 },
65 { 0x3e, 0x00, 0x095, 0x3e, 0x095 },
66 { 0x63, 0x09, 0x091, 0x00, 0x054 },
67 { 0xd3, 0x00, 0x0c0, 0xd3, 0x0c0 },
68 { 0xa9, 0x0b, 0x001, 0x00, 0x054 },
69 { 0xfa, 0x02, 0x800, 0xe8, 0x095 },
70 { 0x90, 0x00, 0x0d5, 0x90, 0x0d5 },
71};
72
73const uint16_t g_cBs3CpuInstr2_shl_amd_TestDataU16 = 28;
74const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shl_amd_TestDataU16[28] =
75{
76 { 0x0000, 0x0f, 0x005, 0x0000, 0x054 },
77 { 0xffff, 0x07, 0x005, 0xff80, 0x091 },
78 { 0x0000, 0x01, 0x010, 0x0000, 0x054 },
79 { 0x000f, 0x04, 0x005, 0x00f0, 0x014 },
80 { 0xecb6, 0x04, 0x051, 0xcb60, 0x89c },
81 { 0xa5a4, 0x05, 0x0c1, 0xb480, 0x898 },
82 { 0x0001, 0x1e, 0x015, 0x0000, 0x054 },
83 { 0x3c5b, 0x11, 0x010, 0x0000, 0x054 },
84 { 0x07c3, 0xf2, 0x001, 0x0000, 0x054 },
85 { 0x022b, 0x0e, 0x084, 0xc000, 0x89c },
86 { 0xb512, 0x01, 0x094, 0x6a24, 0x81d },
87 { 0xe071, 0x06, 0x810, 0x1c40, 0x010 },
88 { 0x0034, 0x0d, 0x0d4, 0x8000, 0x89c },
89 { 0xea50, 0x0c, 0x080, 0x0000, 0x85d },
90 { 0xdaf2, 0x08, 0x0c1, 0xf200, 0x89c },
91 { 0x017b, 0x00, 0x0c4, 0x017b, 0x0c4 },
92 { 0x2a68, 0x10, 0x0d5, 0x0000, 0x054 },
93 { 0x5ca0, 0x08, 0x051, 0xa000, 0x89c },
94 { 0x00d9, 0x13, 0x085, 0x0000, 0x054 },
95 { 0x41eb, 0x0c, 0x015, 0xb000, 0x89c },
96 { 0x4d07, 0x05, 0x0c1, 0xa0e0, 0x091 },
97 { 0x0258, 0x04, 0x0d0, 0x2580, 0x010 },
98 { 0x169f, 0x42, 0x041, 0x5a7c, 0x010 },
99 { 0x5a7c, 0xfd, 0x005, 0x0000, 0x054 },
100 { 0x2d81, 0x06, 0x050, 0x6040, 0x819 },
101 { 0x874b, 0x07, 0x081, 0xa580, 0x091 },
102 { 0xce1a, 0x0c, 0x040, 0xa000, 0x095 },
103 { 0x03de, 0x13, 0x884, 0x0000, 0x054 },
104};
105
106const uint16_t g_cBs3CpuInstr2_shl_amd_TestDataU32 = 32;
107const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shl_amd_TestDataU32[32] =
108{
109 { 0x00000000, 0x1b, 0x000, 0x00000000, 0x054 },
110 { 0xffffffff, 0x35, 0x081, 0xffe00000, 0x095 },
111 { 0x00000000, 0x0c, 0x041, 0x00000000, 0x054 },
112 { 0x9e3c3abd, 0xbb, 0x0c4, 0xe8000000, 0x095 },
113 { 0xa652240a, 0x01, 0x091, 0x4ca44814, 0x81d },
114 { 0x0000016c, 0x0b, 0x884, 0x000b6000, 0x014 },
115 { 0x86c1bf62, 0x35, 0x0d5, 0xec400000, 0x095 },
116 { 0x815ebfe7, 0x3c, 0x084, 0x70000000, 0x014 },
117 { 0xab190947, 0x10, 0x090, 0x09470000, 0x81d },
118 { 0x20727b5b, 0x0d, 0x845, 0x4f6b6000, 0x014 },
119 { 0x00775cde, 0x01, 0x084, 0x00eeb9bc, 0x010 },
120 { 0x38729e0f, 0x1d, 0x094, 0xe0000000, 0x095 },
121 { 0xc5ed8515, 0x14, 0x041, 0x51500000, 0x014 },
122 { 0xc5be6f15, 0x07, 0x084, 0xdf378a80, 0x898 },
123 { 0x2337a582, 0x84, 0x050, 0x337a5820, 0x010 },
124 { 0x0eda3ed9, 0x1a, 0x000, 0x64000000, 0x81d },
125 { 0x92aa10b8, 0x3d, 0x041, 0x00000000, 0x85d },
126 { 0x3a92bec7, 0x00, 0x084, 0x3a92bec7, 0x084 },
127 { 0x3e408f33, 0x20, 0x0d0, 0x3e408f33, 0x0d0 },
128 { 0x5590f087, 0x21, 0x0d5, 0xab21e10e, 0x898 },
129 { 0x0000156f, 0x21, 0x0d5, 0x00002ade, 0x014 },
130 { 0x1d3191a6, 0x21, 0x014, 0x3a63234c, 0x010 },
131 { 0x20b99aa4, 0x21, 0x000, 0x41733548, 0x014 },
132 { 0x6e42277d, 0x21, 0x054, 0xdc844efa, 0x89c },
133 { 0xf9dfbf88, 0x00, 0x804, 0xf9dfbf88, 0x80c },
134 { 0x001ae66e, 0x21, 0x0c1, 0x0035ccdc, 0x010 },
135 { 0x7a00e7b7, 0x21, 0x094, 0xf401cf6e, 0x898 },
136 { 0xe2496524, 0x21, 0x055, 0xc492ca48, 0x095 },
137 { 0xda804f93, 0x21, 0x091, 0xb5009f26, 0x091 },
138 { 0x3b1ff688, 0x21, 0x011, 0x763fed10, 0x010 },
139 { 0x0ae44b3c, 0x21, 0x040, 0x15c89678, 0x014 },
140 { 0x74e76150, 0x21, 0x015, 0xe9cec2a0, 0x89c },
141};
142
143const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU8 = 28;
144const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shr_amd_TestDataU8[28] =
145{
146 { 0x00, 0x01, 0x0d0, 0x00, 0x054 },
147 { 0xff, 0x0b, 0x091, 0x00, 0x054 },
148 { 0x00, 0x00, 0x0c0, 0x00, 0x0c0 },
149 { 0xf8, 0x05, 0x0c0, 0x07, 0x011 },
150 { 0x39, 0x03, 0x084, 0x07, 0x010 },
151 { 0x37, 0x06, 0x010, 0x00, 0x055 },
152 { 0xdf, 0x06, 0x055, 0x03, 0x014 },
153 { 0x0d, 0x37, 0x0c5, 0x00, 0x054 },
154 { 0xd3, 0x06, 0x040, 0x03, 0x014 },
155 { 0x44, 0x01, 0x880, 0x22, 0x014 },
156 { 0xd0, 0x04, 0x010, 0x0d, 0x010 },
157 { 0xf2, 0x08, 0x094, 0x00, 0x055 },
158 { 0x41, 0x0c, 0x014, 0x00, 0x054 },
159 { 0x84, 0x06, 0x054, 0x02, 0x010 },
160 { 0x85, 0x0f, 0x094, 0x00, 0x054 },
161 { 0xc2, 0x09, 0x085, 0x00, 0x054 },
162 { 0x0f, 0x09, 0x040, 0x00, 0x054 },
163 { 0xdf, 0x01, 0x015, 0x6f, 0x81d },
164 { 0x4a, 0x01, 0x010, 0x25, 0x010 },
165 { 0xbe, 0x06, 0x0c1, 0x02, 0x011 },
166 { 0x42, 0x01, 0x041, 0x21, 0x014 },
167 { 0x5a, 0xf2, 0x851, 0x00, 0x054 },
168 { 0xc6, 0x05, 0x804, 0x06, 0x014 },
169 { 0xc1, 0x06, 0x080, 0x03, 0x014 },
170 { 0x60, 0x05, 0x081, 0x03, 0x014 },
171 { 0x03, 0x00, 0x855, 0x03, 0x85d },
172 { 0x85, 0x07, 0x0d5, 0x01, 0x010 },
173 { 0x8c, 0x0f, 0x094, 0x00, 0x054 },
174};
175
176const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU16 = 28;
177const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shr_amd_TestDataU16[28] =
178{
179 { 0x0000, 0x42, 0x054, 0x0000, 0x054 },
180 { 0xffff, 0x0a, 0x015, 0x003f, 0x015 },
181 { 0x0000, 0xc6, 0x085, 0x0000, 0x054 },
182 { 0x0009, 0x05, 0x010, 0x0000, 0x054 },
183 { 0x1b36, 0x18, 0x085, 0x0000, 0x054 },
184 { 0xda49, 0x1b, 0x004, 0x0000, 0x054 },
185 { 0x1c3a, 0x00, 0x894, 0x1c3a, 0x89c },
186 { 0xb0fe, 0x09, 0x005, 0x0058, 0x010 },
187 { 0xa4fc, 0x05, 0x894, 0x0527, 0x015 },
188 { 0x003e, 0xf2, 0x055, 0x0000, 0x054 },
189 { 0x1fa9, 0x01, 0x000, 0x0fd4, 0x015 },
190 { 0xabb9, 0x07, 0x015, 0x0157, 0x010 },
191 { 0x35b9, 0x0a, 0x010, 0x000d, 0x010 },
192 { 0x897e, 0x0a, 0x0d1, 0x0022, 0x014 },
193 { 0x7f8d, 0x0d, 0x0d0, 0x0003, 0x015 },
194 { 0x0038, 0x10, 0x055, 0x0000, 0x054 },
195 { 0x2162, 0x11, 0x000, 0x0000, 0x054 },
196 { 0x2862, 0x11, 0x080, 0x0000, 0x054 },
197 { 0x3ce1, 0x11, 0x0c4, 0x0000, 0x054 },
198 { 0x6c1f, 0x11, 0x091, 0x0000, 0x054 },
199 { 0xcf86, 0x11, 0x051, 0x0000, 0x054 },
200 { 0x0223, 0x11, 0x015, 0x0000, 0x054 },
201 { 0xab4a, 0x11, 0x0c4, 0x0000, 0x054 },
202 { 0x7a0d, 0x11, 0x011, 0x0000, 0x054 },
203 { 0x0074, 0x00, 0x881, 0x0074, 0x889 },
204 { 0x0060, 0x11, 0x001, 0x0000, 0x054 },
205 { 0xd6da, 0x11, 0x814, 0x0000, 0x054 },
206 { 0x094d, 0x11, 0x880, 0x0000, 0x054 },
207};
208
209const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU32 = 32;
210const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shr_amd_TestDataU32[32] =
211{
212 { 0x00000000, 0x16, 0x014, 0x00000000, 0x054 },
213 { 0xffffffff, 0x09, 0x0d0, 0x007fffff, 0x015 },
214 { 0x00000000, 0x32, 0x095, 0x00000000, 0x054 },
215 { 0x6da70247, 0x1f, 0x091, 0x00000000, 0x055 },
216 { 0x4663e2e3, 0x1c, 0x0c0, 0x00000004, 0x010 },
217 { 0x0096989c, 0x39, 0x0d4, 0x00000000, 0x054 },
218 { 0x5f6b47d9, 0x0a, 0x0d1, 0x0017dad1, 0x015 },
219 { 0xd8f2bb7f, 0x08, 0x0d5, 0x00d8f2bb, 0x014 },
220 { 0xae889be6, 0x03, 0x0d4, 0x15d1137c, 0x011 },
221 { 0x4723a408, 0x04, 0x090, 0x04723a40, 0x011 },
222 { 0x7ffffc52, 0x1a, 0x085, 0x0000001f, 0x011 },
223 { 0xd64ae28e, 0x09, 0x0d1, 0x006b2571, 0x014 },
224 { 0xe955c618, 0x0f, 0x085, 0x0001d2ab, 0x011 },
225 { 0xf6c9df26, 0x3f, 0x095, 0x00000001, 0x011 },
226 { 0xc0cbca8a, 0x9a, 0x800, 0x00000030, 0x014 },
227 { 0x00006277, 0x0c, 0x041, 0x00000006, 0x014 },
228 { 0x6bdcaea2, 0x12, 0x005, 0x00001af7, 0x010 },
229 { 0x6202de64, 0x00, 0x0d4, 0x6202de64, 0x0d4 },
230 { 0xb91aaabb, 0x01, 0x004, 0x5c8d555d, 0x819 },
231 { 0xdd87b57b, 0x20, 0x0c1, 0xdd87b57b, 0x0c1 },
232 { 0x0279e831, 0x00, 0x095, 0x0279e831, 0x095 },
233 { 0xab9e2e1b, 0x21, 0x011, 0x55cf170d, 0x819 },
234 { 0x03660d95, 0x21, 0x095, 0x01b306ca, 0x015 },
235 { 0x7a9ac009, 0x01, 0x050, 0x3d4d6004, 0x011 },
236 { 0x32bba1b2, 0x21, 0x091, 0x195dd0d9, 0x010 },
237 { 0x00005665, 0x21, 0x080, 0x00002b32, 0x011 },
238 { 0x7a7856cc, 0x21, 0x045, 0x3d3c2b66, 0x014 },
239 { 0xe17a03fd, 0x21, 0x894, 0x70bd01fe, 0x819 },
240 { 0x17762b84, 0x21, 0x050, 0x0bbb15c2, 0x010 },
241 { 0x5b89b12a, 0x21, 0x001, 0x2dc4d895, 0x014 },
242 { 0x05f492c1, 0x21, 0x0d1, 0x02fa4960, 0x015 },
243 { 0xa39bc0c4, 0x21, 0x055, 0x51cde062, 0x818 },
244};
245
246const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU8 = 28;
247const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_sar_amd_TestDataU8[28] =
248{
249 { 0x00, 0x04, 0x085, 0x00, 0x054 },
250 { 0xff, 0x0b, 0x0c1, 0xff, 0x095 },
251 { 0x00, 0x04, 0x0c4, 0x00, 0x054 },
252 { 0x5b, 0x07, 0x040, 0x00, 0x055 },
253 { 0x66, 0x06, 0x004, 0x01, 0x011 },
254 { 0x42, 0x01, 0x094, 0x21, 0x014 },
255 { 0x50, 0x01, 0x094, 0x28, 0x014 },
256 { 0x5a, 0x04, 0x045, 0x05, 0x015 },
257 { 0xea, 0x01, 0x010, 0xf5, 0x094 },
258 { 0x74, 0x07, 0x094, 0x00, 0x055 },
259 { 0xbb, 0x02, 0x045, 0xee, 0x095 },
260 { 0xee, 0x02, 0x0c4, 0xfb, 0x091 },
261 { 0x97, 0x01, 0x0c0, 0xcb, 0x091 },
262 { 0xf2, 0x4d, 0x084, 0xff, 0x095 },
263 { 0xc1, 0x01, 0x040, 0xe0, 0x091 },
264 { 0x78, 0x00, 0x011, 0x78, 0x011 },
265 { 0xc0, 0x08, 0x005, 0xff, 0x095 },
266 { 0x4a, 0x00, 0x884, 0x4a, 0x88c },
267 { 0x4c, 0x02, 0x0d4, 0x13, 0x010 },
268 { 0xfd, 0x05, 0x811, 0xff, 0x095 },
269 { 0x70, 0x05, 0x004, 0x03, 0x015 },
270 { 0x25, 0x0a, 0x051, 0x00, 0x054 },
271 { 0xe6, 0x05, 0x091, 0xff, 0x094 },
272 { 0xc1, 0x84, 0x0d1, 0xfc, 0x094 },
273 { 0xb9, 0x01, 0x891, 0xdc, 0x091 },
274 { 0x7f, 0x0c, 0x041, 0x00, 0x054 },
275 { 0x0b, 0x01, 0x090, 0x05, 0x015 },
276 { 0x9f, 0x05, 0x000, 0xfc, 0x095 },
277};
278
279const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU16 = 28;
280const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_sar_amd_TestDataU16[28] =
281{
282 { 0x0000, 0x1b, 0x015, 0x0000, 0x054 },
283 { 0xffff, 0x02, 0x815, 0xffff, 0x095 },
284 { 0x0000, 0x00, 0x005, 0x0000, 0x005 },
285 { 0x2bc5, 0x0a, 0x0d5, 0x000a, 0x015 },
286 { 0x3a7d, 0x0c, 0x001, 0x0003, 0x015 },
287 { 0xdf07, 0x0c, 0x044, 0xfffd, 0x091 },
288 { 0x1fb9, 0x0a, 0x045, 0x0007, 0x011 },
289 { 0x0f0d, 0x06, 0x0c1, 0x003c, 0x014 },
290 { 0xeeb4, 0x09, 0x0c0, 0xfff7, 0x090 },
291 { 0x024d, 0x06, 0x0c1, 0x0009, 0x014 },
292 { 0xdbe9, 0x01, 0x095, 0xedf4, 0x091 },
293 { 0x808f, 0x09, 0x0d0, 0xffc0, 0x094 },
294 { 0x00ae, 0x15, 0x000, 0x0000, 0x054 },
295 { 0x2f25, 0xe7, 0x011, 0x005e, 0x010 },
296 { 0x88a6, 0x03, 0x054, 0xf114, 0x095 },
297 { 0x003a, 0x10, 0x085, 0x0000, 0x054 },
298 { 0xa89e, 0x11, 0x854, 0xffff, 0x095 },
299 { 0x0065, 0x00, 0x854, 0x0065, 0x85c },
300 { 0x02c7, 0x0f, 0x005, 0x0000, 0x054 },
301 { 0xf01f, 0x05, 0x045, 0xff80, 0x091 },
302 { 0x90bf, 0x05, 0x0d4, 0xfc85, 0x091 },
303 { 0x0012, 0x0a, 0x011, 0x0000, 0x054 },
304 { 0x536f, 0x09, 0x0c0, 0x0029, 0x011 },
305 { 0xcb4f, 0x0e, 0x005, 0xffff, 0x094 },
306 { 0x181c, 0x0a, 0x041, 0x0006, 0x014 },
307 { 0x11da, 0x15, 0x850, 0x0000, 0x054 },
308 { 0x05af, 0xfd, 0x014, 0x0000, 0x054 },
309 { 0x0487, 0x01, 0x0c1, 0x0243, 0x011 },
310};
311
312const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU32 = 32;
313const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_sar_amd_TestDataU32[32] =
314{
315 { 0x00000000, 0x0d, 0x044, 0x00000000, 0x054 },
316 { 0xffffffff, 0xd1, 0x041, 0xffffffff, 0x095 },
317 { 0x00000000, 0x07, 0x0d4, 0x00000000, 0x054 },
318 { 0x13414b64, 0x37, 0x090, 0x00000026, 0x011 },
319 { 0x19718c16, 0x0b, 0x091, 0x00032e31, 0x011 },
320 { 0x00000099, 0x1e, 0x085, 0x00000000, 0x054 },
321 { 0x636b4dde, 0x02, 0x054, 0x18dad377, 0x015 },
322 { 0xc76db72d, 0x0c, 0x804, 0xfffc76db, 0x094 },
323 { 0xa97a5c08, 0x10, 0x814, 0xffffa97a, 0x090 },
324 { 0x183840bd, 0x15, 0x094, 0x000000c1, 0x011 },
325 { 0x000066fa, 0x84, 0x080, 0x0000066f, 0x015 },
326 { 0x29482914, 0x36, 0x095, 0x000000a5, 0x014 },
327 { 0xd2fc08bd, 0x21, 0x005, 0xe97e045e, 0x091 },
328 { 0x8b5dc996, 0x18, 0x040, 0xffffff8b, 0x094 },
329 { 0x3b7a0e67, 0x0c, 0x0d4, 0x0003b7a0, 0x015 },
330 { 0x000f586b, 0x0d, 0x041, 0x0000007a, 0x011 },
331 { 0x308bf137, 0x02, 0x005, 0x0c22fc4d, 0x015 },
332 { 0xb88ec035, 0x00, 0x0c0, 0xb88ec035, 0x0c0 },
333 { 0x2c3411a2, 0x01, 0x0d4, 0x161a08d1, 0x014 },
334 { 0x60b0e0fa, 0x20, 0x080, 0x60b0e0fa, 0x080 },
335 { 0x00017fa0, 0x1e, 0x081, 0x00000000, 0x054 },
336 { 0x60f5703d, 0x00, 0x845, 0x60f5703d, 0x84d },
337 { 0x294081ac, 0x1b, 0x011, 0x00000005, 0x014 },
338 { 0xc571ba90, 0x19, 0x040, 0xffffffe2, 0x095 },
339 { 0x798a9271, 0x12, 0x890, 0x00001e62, 0x011 },
340 { 0x0000193d, 0x0c, 0x044, 0x00000001, 0x011 },
341 { 0x79136779, 0x20, 0x0d1, 0x79136779, 0x0d1 },
342 { 0xea400bb9, 0x15, 0x084, 0xffffff52, 0x090 },
343 { 0x531f684e, 0x8f, 0x010, 0x0000a63e, 0x011 },
344 { 0x16b6807f, 0x03, 0x014, 0x02d6d00f, 0x015 },
345 { 0x000004f8, 0x1a, 0x045, 0x00000000, 0x054 },
346 { 0x0da19b96, 0x08, 0x0c4, 0x000da19b, 0x011 },
347};
348
349const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU8 = 28;
350const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rol_amd_TestDataU8[28] =
351{
352 { 0x00, 0x03, 0x011, 0x00, 0x010 },
353 { 0xff, 0x04, 0x805, 0xff, 0x005 },
354 { 0x00, 0x03, 0x015, 0x00, 0x014 },
355 { 0x2c, 0x00, 0x891, 0x2c, 0x899 },
356 { 0xc7, 0x01, 0x041, 0x8f, 0x041 },
357 { 0x1c, 0x03, 0x085, 0xe0, 0x88c },
358 { 0xae, 0x06, 0x0d5, 0xab, 0x0d5 },
359 { 0x50, 0x16, 0x091, 0x14, 0x090 },
360 { 0x4c, 0x08, 0x000, 0x4c, 0x000 },
361 { 0xf1, 0x05, 0x084, 0x3e, 0x084 },
362 { 0xfe, 0x03, 0x090, 0xf7, 0x091 },
363 { 0xc6, 0x05, 0x894, 0xd8, 0x89c },
364 { 0xbf, 0x03, 0x015, 0xfd, 0x015 },
365 { 0x48, 0x03, 0x894, 0x42, 0x094 },
366 { 0xed, 0x05, 0x090, 0xbd, 0x091 },
367 { 0xba, 0x09, 0x084, 0x75, 0x88d },
368 { 0x61, 0x00, 0x045, 0x61, 0x045 },
369 { 0x18, 0x09, 0x080, 0x30, 0x080 },
370 { 0xdb, 0x09, 0x055, 0xb7, 0x055 },
371 { 0xca, 0x09, 0x044, 0x95, 0x045 },
372 { 0x97, 0x09, 0x004, 0x2f, 0x80d },
373 { 0x66, 0x09, 0x0c1, 0xcc, 0x8c8 },
374 { 0x7f, 0x09, 0x040, 0xfe, 0x848 },
375 { 0xa8, 0x09, 0x055, 0x51, 0x85d },
376 { 0xbe, 0x09, 0x095, 0x7d, 0x89d },
377 { 0xc2, 0x09, 0x015, 0x85, 0x015 },
378 { 0xdb, 0x01, 0x041, 0xb7, 0x041 },
379 { 0x38, 0x08, 0x045, 0x38, 0x044 },
380};
381
382const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU16 = 28;
383const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rol_amd_TestDataU16[28] =
384{
385 { 0x0000, 0x0e, 0x015, 0x0000, 0x014 },
386 { 0xffff, 0xd1, 0x084, 0xffff, 0x085 },
387 { 0x0000, 0x0f, 0x084, 0x0000, 0x084 },
388 { 0x0003, 0x03, 0x095, 0x0018, 0x094 },
389 { 0xbc65, 0x09, 0x0d4, 0xcb78, 0x8dc },
390 { 0xa5ea, 0x19, 0x8d1, 0xd54b, 0x0d1 },
391 { 0x00a3, 0x0e, 0x045, 0xc028, 0x84c },
392 { 0xd46b, 0x09, 0x895, 0xd7a8, 0x89c },
393 { 0x0628, 0x0c, 0x000, 0x8062, 0x808 },
394 { 0x0069, 0x05, 0x000, 0x0d20, 0x000 },
395 { 0x9305, 0x00, 0x051, 0x9305, 0x051 },
396 { 0xca4e, 0x1b, 0x8d5, 0x7652, 0x0d4 },
397 { 0x06da, 0x0a, 0x054, 0x681b, 0x85d },
398 { 0xae4d, 0x05, 0x0c5, 0xc9b5, 0x0c5 },
399 { 0x2f55, 0x04, 0x011, 0xf552, 0x818 },
400 { 0x0b52, 0x01, 0x004, 0x16a4, 0x004 },
401 { 0x02f1, 0x10, 0x055, 0x02f1, 0x85d },
402 { 0xc1c5, 0x11, 0x0c4, 0x838b, 0x0c5 },
403 { 0x32fe, 0x11, 0x0c4, 0x65fc, 0x0c4 },
404 { 0x589b, 0x11, 0x0d5, 0xb136, 0x8dc },
405 { 0x90c8, 0x11, 0x014, 0x2191, 0x81d },
406 { 0x00f6, 0x11, 0x004, 0x01ec, 0x004 },
407 { 0x085d, 0x11, 0x010, 0x10ba, 0x010 },
408 { 0x65af, 0x11, 0x000, 0xcb5e, 0x808 },
409 { 0x0441, 0x11, 0x015, 0x0882, 0x014 },
410 { 0xfed1, 0x11, 0x041, 0xfda3, 0x041 },
411 { 0x632b, 0x01, 0x0c1, 0xc656, 0x8c8 },
412 { 0x0003, 0x11, 0x854, 0x0006, 0x054 },
413};
414
415const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU32 = 32;
416const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rol_amd_TestDataU32[32] =
417{
418 { 0x00000000, 0x1a, 0x084, 0x00000000, 0x084 },
419 { 0xffffffff, 0x11, 0x051, 0xffffffff, 0x051 },
420 { 0x00000000, 0x24, 0x0d4, 0x00000000, 0x0d4 },
421 { 0xe7b0a77b, 0x09, 0x094, 0x614ef7cf, 0x89d },
422 { 0x94c00665, 0x12, 0x055, 0x19965300, 0x054 },
423 { 0x169ca9fd, 0x1f, 0x054, 0x8b4e54fe, 0x85c },
424 { 0x1d97f73d, 0x1a, 0x010, 0xf4765fdc, 0x818 },
425 { 0xf22bf929, 0x0e, 0x051, 0xfe4a7c8a, 0x858 },
426 { 0x082ec0c0, 0x1b, 0x095, 0x00417606, 0x094 },
427 { 0x3f6da6b4, 0x0a, 0x005, 0xb69ad0fd, 0x005 },
428 { 0x000304cd, 0x09, 0x055, 0x06099a00, 0x054 },
429 { 0x0b0d2604, 0x17, 0x001, 0x02058693, 0x809 },
430 { 0x51959f0e, 0x04, 0x001, 0x1959f0e5, 0x809 },
431 { 0x47ec7558, 0x0d, 0x041, 0x8eab08fd, 0x041 },
432 { 0x875c8d88, 0x10, 0x044, 0x8d88875c, 0x84c },
433 { 0x02c9af3d, 0x2e, 0x094, 0x6bcf40b2, 0x094 },
434 { 0x24267800, 0x05, 0x010, 0x84cf0004, 0x818 },
435 { 0xde69073e, 0x00, 0x051, 0xde69073e, 0x051 },
436 { 0xd989dd88, 0x01, 0x010, 0xb313bb11, 0x011 },
437 { 0x2a77200b, 0x20, 0x005, 0x2a77200b, 0x005 },
438 { 0x00000828, 0x21, 0x004, 0x00001050, 0x004 },
439 { 0xf2123f6c, 0x21, 0x0d1, 0xe4247ed9, 0x0d1 },
440 { 0xbeee6088, 0x21, 0x015, 0x7ddcc111, 0x81d },
441 { 0x79e47777, 0x21, 0x015, 0xf3c8eeee, 0x81c },
442 { 0xac56d286, 0x21, 0x0d4, 0x58ada50d, 0x8dd },
443 { 0x0025ae38, 0x21, 0x015, 0x004b5c70, 0x014 },
444 { 0x89664d5e, 0x21, 0x085, 0x12cc9abd, 0x88d },
445 { 0x3de60ec9, 0x21, 0x0c0, 0x7bcc1d92, 0x0c0 },
446 { 0x43fd768e, 0x21, 0x014, 0x87faed1c, 0x81c },
447 { 0x7d530623, 0x21, 0x040, 0xfaa60c46, 0x848 },
448 { 0x00894d74, 0x21, 0x0c5, 0x01129ae8, 0x0c4 },
449 { 0xb5766753, 0x21, 0x054, 0x6aeccea7, 0x85d },
450};
451
452const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU8 = 28;
453const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_ror_amd_TestDataU8[28] =
454{
455 { 0x00, 0x07, 0x080, 0x00, 0x080 },
456 { 0xff, 0x09, 0x095, 0xff, 0x095 },
457 { 0x00, 0x01, 0x0c5, 0x00, 0x0c4 },
458 { 0x89, 0x06, 0x885, 0x26, 0x084 },
459 { 0xbc, 0x0c, 0x001, 0xcb, 0x001 },
460 { 0x49, 0x01, 0x085, 0xa4, 0x88d },
461 { 0x32, 0x07, 0x050, 0x64, 0x858 },
462 { 0xe3, 0x01, 0x051, 0xf1, 0x051 },
463 { 0xf6, 0x02, 0x015, 0xbd, 0x81d },
464 { 0xca, 0x02, 0x010, 0xb2, 0x819 },
465 { 0x6e, 0x0d, 0x090, 0x73, 0x898 },
466 { 0xfd, 0x04, 0x004, 0xdf, 0x005 },
467 { 0xe8, 0x04, 0x040, 0x8e, 0x849 },
468 { 0x3c, 0x04, 0x095, 0xc3, 0x095 },
469 { 0x5d, 0x0b, 0x095, 0xab, 0x89d },
470 { 0xa6, 0x00, 0x0c0, 0xa6, 0x0c0 },
471 { 0xf5, 0x08, 0x041, 0xf5, 0x041 },
472 { 0x48, 0x05, 0x051, 0x42, 0x858 },
473 { 0x2f, 0x04, 0x055, 0xf2, 0x055 },
474 { 0x48, 0xfd, 0x080, 0x42, 0x888 },
475 { 0x1a, 0x01, 0x081, 0x0d, 0x080 },
476 { 0x21, 0x00, 0x841, 0x21, 0x849 },
477 { 0x1f, 0x05, 0x015, 0xf8, 0x015 },
478 { 0xc3, 0x8f, 0x015, 0x87, 0x81d },
479 { 0x03, 0x05, 0x045, 0x18, 0x044 },
480 { 0xda, 0x07, 0x084, 0xb5, 0x88d },
481 { 0x2f, 0x00, 0x015, 0x2f, 0x015 },
482 { 0x0f, 0x0b, 0x0d5, 0xe1, 0x0d5 },
483};
484
485const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU16 = 28;
486const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_ror_amd_TestDataU16[28] =
487{
488 { 0x0000, 0x17, 0x045, 0x0000, 0x044 },
489 { 0xffff, 0x0a, 0x0d1, 0xffff, 0x0d1 },
490 { 0x0000, 0x03, 0x045, 0x0000, 0x044 },
491 { 0x002c, 0xb0, 0x010, 0x002c, 0x010 },
492 { 0x7ceb, 0x01, 0x094, 0xbe75, 0x89d },
493 { 0x14de, 0x84, 0x095, 0xe14d, 0x095 },
494 { 0x076c, 0xd1, 0x001, 0x03b6, 0x000 },
495 { 0x1ec9, 0x0e, 0x000, 0x7b24, 0x808 },
496 { 0x4279, 0xe7, 0x011, 0xf284, 0x011 },
497 { 0x04c6, 0x14, 0x0c5, 0x604c, 0x8cc },
498 { 0x502c, 0x15, 0x051, 0x6281, 0x858 },
499 { 0x1f92, 0x13, 0x051, 0x43f2, 0x858 },
500 { 0x105b, 0x00, 0x0c5, 0x105b, 0x0c5 },
501 { 0x7db1, 0x84, 0x095, 0x17db, 0x094 },
502 { 0x6ee5, 0x1a, 0x044, 0xb95b, 0x84d },
503 { 0x0244, 0x00, 0x841, 0x0244, 0x849 },
504 { 0xf88a, 0x10, 0x084, 0xf88a, 0x085 },
505 { 0xf21b, 0x11, 0x0d4, 0xf90d, 0x0d5 },
506 { 0x0044, 0x11, 0x014, 0x0022, 0x014 },
507 { 0x6a5e, 0x11, 0x811, 0x352f, 0x010 },
508 { 0xedc9, 0x11, 0x0d5, 0xf6e4, 0x0d5 },
509 { 0x0049, 0x11, 0x045, 0x8024, 0x84d },
510 { 0x5cbc, 0x11, 0x090, 0x2e5e, 0x090 },
511 { 0x5e66, 0x11, 0x000, 0x2f33, 0x000 },
512 { 0x0071, 0x11, 0x041, 0x8038, 0x849 },
513 { 0xe91e, 0x11, 0x815, 0x748f, 0x81c },
514 { 0xbd66, 0x11, 0x041, 0x5eb3, 0x848 },
515 { 0x01e8, 0x11, 0x0d1, 0x00f4, 0x0d0 },
516};
517
518const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU32 = 32;
519const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_ror_amd_TestDataU32[32] =
520{
521 { 0x00000000, 0x1f, 0x095, 0x00000000, 0x094 },
522 { 0xffffffff, 0x17, 0x014, 0xffffffff, 0x015 },
523 { 0x00000000, 0x1b, 0x014, 0x00000000, 0x014 },
524 { 0xb6eacec3, 0x03, 0x011, 0x76dd59d8, 0x818 },
525 { 0xe84bc0b3, 0x1e, 0x051, 0xa12f02cf, 0x859 },
526 { 0x0000972c, 0x39, 0x041, 0x004b9600, 0x040 },
527 { 0xdddadf0e, 0x07, 0x054, 0x1dbbb5be, 0x054 },
528 { 0xa12e8ba2, 0x11, 0x000, 0x45d15097, 0x808 },
529 { 0x368f5a93, 0x1a, 0x044, 0xa3d6a4cd, 0x84d },
530 { 0x126a6ba8, 0x20, 0x0d1, 0x126a6ba8, 0x0d1 },
531 { 0x0000341c, 0x32, 0x005, 0x0d070000, 0x004 },
532 { 0x1dac8fbd, 0x11, 0x015, 0x47de8ed6, 0x81c },
533 { 0x6e54b64c, 0xfd, 0x081, 0x72a5b263, 0x888 },
534 { 0xeeaed664, 0x16, 0x044, 0xbb5993ba, 0x84d },
535 { 0xfe209858, 0x06, 0x0d0, 0x63f88261, 0x8d8 },
536 { 0x20355f08, 0x0b, 0x081, 0xe10406ab, 0x081 },
537 { 0xd9deb810, 0x2a, 0x001, 0x043677ae, 0x000 },
538 { 0x849eb483, 0x00, 0x045, 0x849eb483, 0x045 },
539 { 0x533947ab, 0x01, 0x0c0, 0xa99ca3d5, 0x8c9 },
540 { 0x3a46f9b4, 0x21, 0x054, 0x1d237cda, 0x054 },
541 { 0x033c6ba2, 0x21, 0x0d5, 0x019e35d1, 0x0d4 },
542 { 0x54904547, 0x21, 0x081, 0xaa4822a3, 0x889 },
543 { 0x0930026c, 0x21, 0x804, 0x04980136, 0x004 },
544 { 0xe095d7d6, 0x21, 0x014, 0x704aebeb, 0x81c },
545 { 0xf43be565, 0x21, 0x054, 0xfa1df2b2, 0x055 },
546 { 0x18c6635a, 0x21, 0x0d5, 0x0c6331ad, 0x0d4 },
547 { 0xe3fc902a, 0x21, 0x0d5, 0x71fe4815, 0x8dc },
548 { 0xa769616d, 0x21, 0x051, 0xd3b4b0b6, 0x051 },
549 { 0x071d255c, 0x21, 0x801, 0x038e92ae, 0x000 },
550 { 0x5642d658, 0x21, 0x081, 0x2b216b2c, 0x080 },
551 { 0x058526fe, 0x21, 0x000, 0x02c2937f, 0x000 },
552 { 0x4997725c, 0x21, 0x004, 0x24cbb92e, 0x004 },
553};
554
555const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU8 = 56;
556const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcl_amd_TestDataU8[56] =
557{
558 { 0x00, 0x04, 0x050, 0x00, 0x050 },
559 { 0x00, 0x04, 0x051, 0x08, 0x050 },
560 { 0xff, 0x05, 0x000, 0xef, 0x001 },
561 { 0xff, 0x05, 0x001, 0xff, 0x001 },
562 { 0x00, 0x0a, 0x894, 0x00, 0x094 },
563 { 0x00, 0x0a, 0x895, 0x01, 0x094 },
564 { 0x75, 0x0e, 0x044, 0xa7, 0x84c },
565 { 0x75, 0x0e, 0x045, 0xb7, 0x84c },
566 { 0x0f, 0x06, 0x040, 0xc1, 0x041 },
567 { 0x0f, 0x06, 0x041, 0xe1, 0x041 },
568 { 0x7c, 0x01, 0x094, 0xf8, 0x89c },
569 { 0x7c, 0x01, 0x095, 0xf9, 0x89c },
570 { 0x04, 0x06, 0x0d0, 0x00, 0x8d9 },
571 { 0x04, 0x06, 0x0d1, 0x20, 0x8d9 },
572 { 0xa8, 0x06, 0x080, 0x15, 0x080 },
573 { 0xa8, 0x06, 0x081, 0x35, 0x080 },
574 { 0xfa, 0x02, 0x0d4, 0xe9, 0x0d5 },
575 { 0xfa, 0x02, 0x0d5, 0xeb, 0x0d5 },
576 { 0x84, 0x0f, 0x090, 0x10, 0x899 },
577 { 0x84, 0x0f, 0x091, 0x30, 0x899 },
578 { 0x01, 0x05, 0x010, 0x20, 0x010 },
579 { 0x01, 0x05, 0x011, 0x30, 0x010 },
580 { 0x7b, 0xb0, 0x094, 0x9e, 0x095 },
581 { 0x7b, 0xb0, 0x095, 0xde, 0x095 },
582 { 0xdc, 0x02, 0x044, 0x71, 0x84d },
583 { 0xdc, 0x02, 0x045, 0x73, 0x84d },
584 { 0x42, 0x02, 0x004, 0x08, 0x80d },
585 { 0x42, 0x02, 0x005, 0x0a, 0x80d },
586 { 0x1d, 0x06, 0x054, 0x43, 0x85d },
587 { 0x1d, 0x06, 0x055, 0x63, 0x85d },
588 { 0xc9, 0x00, 0x000, 0xc9, 0x000 },
589 { 0xc9, 0x00, 0x001, 0xc9, 0x001 },
590 { 0x0e, 0x08, 0x044, 0x07, 0x044 },
591 { 0x0e, 0x08, 0x045, 0x87, 0x84c },
592 { 0x87, 0x09, 0x090, 0x87, 0x898 },
593 { 0x87, 0x09, 0x091, 0x87, 0x091 },
594 { 0x00, 0x09, 0x054, 0x00, 0x054 },
595 { 0x00, 0x09, 0x055, 0x00, 0x85d },
596 { 0x27, 0x09, 0x014, 0x27, 0x014 },
597 { 0x27, 0x09, 0x015, 0x27, 0x81d },
598 { 0x2e, 0x09, 0x054, 0x2e, 0x054 },
599 { 0x2e, 0x09, 0x055, 0x2e, 0x85d },
600 { 0x1c, 0x09, 0x000, 0x1c, 0x000 },
601 { 0x1c, 0x09, 0x001, 0x1c, 0x809 },
602 { 0xb2, 0x09, 0x084, 0xb2, 0x88c },
603 { 0xb2, 0x09, 0x085, 0xb2, 0x085 },
604 { 0x9c, 0x09, 0x044, 0x9c, 0x84c },
605 { 0x9c, 0x09, 0x045, 0x9c, 0x045 },
606 { 0xea, 0x09, 0x040, 0xea, 0x848 },
607 { 0xea, 0x09, 0x041, 0xea, 0x041 },
608 { 0xae, 0x01, 0x050, 0x5c, 0x859 },
609 { 0xae, 0x01, 0x051, 0x5d, 0x859 },
610 { 0x3e, 0x01, 0x080, 0x7c, 0x080 },
611 { 0x3e, 0x01, 0x081, 0x7d, 0x080 },
612 { 0xc3, 0x00, 0x010, 0xc3, 0x010 },
613 { 0xc3, 0x00, 0x011, 0xc3, 0x011 },
614};
615
616const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU16 = 56;
617const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcl_amd_TestDataU16[56] =
618{
619 { 0x0000, 0x06, 0x840, 0x0000, 0x040 },
620 { 0x0000, 0x06, 0x841, 0x0020, 0x040 },
621 { 0xffff, 0x0b, 0x0d4, 0xfbff, 0x0d5 },
622 { 0xffff, 0x0b, 0x0d5, 0xffff, 0x0d5 },
623 { 0x0000, 0x0b, 0x090, 0x0000, 0x090 },
624 { 0x0000, 0x0b, 0x091, 0x0400, 0x090 },
625 { 0x00ea, 0x07, 0x014, 0x7500, 0x014 },
626 { 0x00ea, 0x07, 0x015, 0x7540, 0x014 },
627 { 0xb7d5, 0x00, 0x080, 0xb7d5, 0x080 },
628 { 0xb7d5, 0x00, 0x081, 0xb7d5, 0x081 },
629 { 0x3b72, 0x18, 0x004, 0xb90e, 0x005 },
630 { 0x3b72, 0x18, 0x005, 0xb94e, 0x005 },
631 { 0x0ded, 0x02, 0x084, 0x37b4, 0x084 },
632 { 0x0ded, 0x02, 0x085, 0x37b6, 0x084 },
633 { 0x15fe, 0x0f, 0x814, 0x057f, 0x81d },
634 { 0x15fe, 0x0f, 0x815, 0x457f, 0x81d },
635 { 0xe681, 0xb0, 0x040, 0x7340, 0x849 },
636 { 0xe681, 0xb0, 0x041, 0xf340, 0x041 },
637 { 0x543d, 0x02, 0x054, 0x50f4, 0x85d },
638 { 0x543d, 0x02, 0x055, 0x50f6, 0x85d },
639 { 0xfe5d, 0xe7, 0x0c0, 0x2ebf, 0x8c9 },
640 { 0xfe5d, 0xe7, 0x0c1, 0x2eff, 0x8c9 },
641 { 0x14d7, 0x01, 0x0d0, 0x29ae, 0x0d0 },
642 { 0x14d7, 0x01, 0x0d1, 0x29af, 0x0d0 },
643 { 0x044e, 0xf2, 0x040, 0x089c, 0x040 },
644 { 0x044e, 0xf2, 0x041, 0x089d, 0x040 },
645 { 0x9c3e, 0x0f, 0x000, 0x270f, 0x809 },
646 { 0x9c3e, 0x0f, 0x001, 0x670f, 0x809 },
647 { 0xb604, 0x01, 0x010, 0x6c08, 0x819 },
648 { 0xb604, 0x01, 0x011, 0x6c09, 0x819 },
649 { 0x0e51, 0x10, 0x0d0, 0x0728, 0x8d9 },
650 { 0x0e51, 0x10, 0x0d1, 0x8728, 0x0d1 },
651 { 0x376d, 0x01, 0x040, 0x6eda, 0x040 },
652 { 0x376d, 0x01, 0x041, 0x6edb, 0x040 },
653 { 0x9904, 0x11, 0x040, 0x9904, 0x848 },
654 { 0x9904, 0x11, 0x041, 0x9904, 0x041 },
655 { 0x068d, 0x11, 0x000, 0x068d, 0x000 },
656 { 0x068d, 0x11, 0x001, 0x068d, 0x809 },
657 { 0xb6c3, 0x11, 0x050, 0xb6c3, 0x858 },
658 { 0xb6c3, 0x11, 0x051, 0xb6c3, 0x051 },
659 { 0xd637, 0x11, 0x014, 0xd637, 0x81c },
660 { 0xd637, 0x11, 0x015, 0xd637, 0x015 },
661 { 0x0013, 0x11, 0x844, 0x0013, 0x044 },
662 { 0x0013, 0x11, 0x845, 0x0013, 0x84d },
663 { 0xb5fc, 0x11, 0x884, 0xb5fc, 0x88c },
664 { 0xb5fc, 0x11, 0x885, 0xb5fc, 0x085 },
665 { 0xbfd8, 0x11, 0x014, 0xbfd8, 0x81c },
666 { 0xbfd8, 0x11, 0x015, 0xbfd8, 0x015 },
667 { 0x023a, 0x11, 0x090, 0x023a, 0x090 },
668 { 0x023a, 0x11, 0x091, 0x023a, 0x899 },
669 { 0x4a65, 0x11, 0x804, 0x4a65, 0x004 },
670 { 0x4a65, 0x11, 0x805, 0x4a65, 0x80d },
671 { 0x7b69, 0x11, 0x0c4, 0x7b69, 0x0c4 },
672 { 0x7b69, 0x11, 0x0c5, 0x7b69, 0x8cd },
673 { 0x0010, 0x11, 0x010, 0x0010, 0x010 },
674 { 0x0010, 0x11, 0x011, 0x0010, 0x819 },
675};
676
677const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU32 = 64;
678const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcl_amd_TestDataU32[64] =
679{
680 { 0x00000000, 0x10, 0x840, 0x00000000, 0x040 },
681 { 0x00000000, 0x10, 0x841, 0x00008000, 0x040 },
682 { 0xffffffff, 0x04, 0x850, 0xfffffff7, 0x051 },
683 { 0xffffffff, 0x04, 0x851, 0xffffffff, 0x051 },
684 { 0x00000000, 0x10, 0x844, 0x00000000, 0x044 },
685 { 0x00000000, 0x10, 0x845, 0x00008000, 0x044 },
686 { 0x0df16aa9, 0x37, 0x004, 0x54837c5a, 0x80d },
687 { 0x0df16aa9, 0x37, 0x005, 0x54c37c5a, 0x80d },
688 { 0x59c43ef9, 0x05, 0x044, 0x3887df25, 0x84d },
689 { 0x59c43ef9, 0x05, 0x045, 0x3887df35, 0x84d },
690 { 0x00000352, 0x1e, 0x0d0, 0x8000006a, 0x8d8 },
691 { 0x00000352, 0x1e, 0x0d1, 0xa000006a, 0x8d8 },
692 { 0xaae7ce38, 0x0b, 0x090, 0x3e71c2ab, 0x899 },
693 { 0xaae7ce38, 0x0b, 0x091, 0x3e71c6ab, 0x899 },
694 { 0x44066b48, 0x16, 0x890, 0xd20880cd, 0x898 },
695 { 0x44066b48, 0x16, 0x891, 0xd22880cd, 0x898 },
696 { 0xbcae822c, 0x1d, 0x010, 0x8bcae822, 0x011 },
697 { 0xbcae822c, 0x1d, 0x011, 0x9bcae822, 0x011 },
698 { 0x7bc0de3e, 0x33, 0x044, 0xf1f1ef03, 0x84c },
699 { 0x7bc0de3e, 0x33, 0x045, 0xf1f5ef03, 0x84c },
700 { 0x000001cb, 0x3c, 0x8c4, 0xb000000e, 0x8cc },
701 { 0x000001cb, 0x3c, 0x8c5, 0xb800000e, 0x8cc },
702 { 0xfabaea5d, 0x1f, 0x044, 0xbeaeba97, 0x84c },
703 { 0xfabaea5d, 0x1f, 0x045, 0xfeaeba97, 0x84c },
704 { 0xd9add652, 0x10, 0x054, 0xd6526cd6, 0x055 },
705 { 0xd9add652, 0x10, 0x055, 0xd652ecd6, 0x055 },
706 { 0xaecc4bae, 0x0d, 0x0d4, 0x8975caec, 0x0d5 },
707 { 0xaecc4bae, 0x0d, 0x0d5, 0x8975daec, 0x0d5 },
708 { 0x4ef76abc, 0x14, 0x000, 0xabc277bb, 0x808 },
709 { 0x4ef76abc, 0x14, 0x001, 0xabca77bb, 0x808 },
710 { 0x056f0ce3, 0x0e, 0x090, 0xc338c0ad, 0x091 },
711 { 0x056f0ce3, 0x0e, 0x091, 0xc338e0ad, 0x091 },
712 { 0xe3cb3741, 0x0f, 0x054, 0x9ba0b8f2, 0x055 },
713 { 0xe3cb3741, 0x0f, 0x055, 0x9ba0f8f2, 0x055 },
714 { 0xb8358bbe, 0x00, 0x054, 0xb8358bbe, 0x054 },
715 { 0xb8358bbe, 0x00, 0x055, 0xb8358bbe, 0x055 },
716 { 0xe880efd1, 0x01, 0x080, 0xd101dfa2, 0x081 },
717 { 0xe880efd1, 0x01, 0x081, 0xd101dfa3, 0x081 },
718 { 0xef121c9e, 0x20, 0x044, 0xef121c9e, 0x044 },
719 { 0xef121c9e, 0x20, 0x045, 0xef121c9e, 0x045 },
720 { 0x000b5c3a, 0x21, 0x040, 0x0016b874, 0x040 },
721 { 0x000b5c3a, 0x21, 0x041, 0x0016b875, 0x040 },
722 { 0xa9cc7bfd, 0x21, 0x0c0, 0x5398f7fa, 0x8c9 },
723 { 0xa9cc7bfd, 0x21, 0x0c1, 0x5398f7fb, 0x8c9 },
724 { 0xb01e6d49, 0x21, 0x050, 0x603cda92, 0x859 },
725 { 0xb01e6d49, 0x21, 0x051, 0x603cda93, 0x859 },
726 { 0x37331e6a, 0x21, 0x050, 0x6e663cd4, 0x050 },
727 { 0x37331e6a, 0x21, 0x051, 0x6e663cd5, 0x050 },
728 { 0x3ac64553, 0x01, 0x050, 0x758c8aa6, 0x050 },
729 { 0x3ac64553, 0x01, 0x051, 0x758c8aa7, 0x050 },
730 { 0x03af72f6, 0x21, 0x890, 0x075ee5ec, 0x090 },
731 { 0x03af72f6, 0x21, 0x891, 0x075ee5ed, 0x090 },
732 { 0x448551f6, 0x21, 0x004, 0x890aa3ec, 0x80c },
733 { 0x448551f6, 0x21, 0x005, 0x890aa3ed, 0x80c },
734 { 0xdb5e2e8a, 0x21, 0x000, 0xb6bc5d14, 0x001 },
735 { 0xdb5e2e8a, 0x21, 0x001, 0xb6bc5d15, 0x001 },
736 { 0x6795540c, 0x21, 0x040, 0xcf2aa818, 0x848 },
737 { 0x6795540c, 0x21, 0x041, 0xcf2aa819, 0x848 },
738 { 0x0c8c3cdf, 0x21, 0x094, 0x191879be, 0x094 },
739 { 0x0c8c3cdf, 0x21, 0x095, 0x191879bf, 0x094 },
740 { 0x003cd8fd, 0x21, 0x044, 0x0079b1fa, 0x044 },
741 { 0x003cd8fd, 0x21, 0x045, 0x0079b1fb, 0x044 },
742 { 0xca92a283, 0x21, 0x010, 0x95254506, 0x011 },
743 { 0xca92a283, 0x21, 0x011, 0x95254507, 0x011 },
744};
745
746const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU8 = 56;
747const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcr_amd_TestDataU8[56] =
748{
749 { 0x00, 0x00, 0x890, 0x00, 0x898 },
750 { 0x00, 0x00, 0x891, 0x00, 0x899 },
751 { 0xff, 0xbb, 0x010, 0xff, 0x010 },
752 { 0xff, 0xbb, 0x011, 0xff, 0x011 },
753 { 0x00, 0x0a, 0x040, 0x00, 0x040 },
754 { 0x00, 0x0a, 0x041, 0x80, 0x848 },
755 { 0x91, 0x0c, 0x084, 0x52, 0x88c },
756 { 0x91, 0x0c, 0x085, 0x72, 0x88c },
757 { 0xa8, 0x03, 0x0d4, 0x15, 0x0d4 },
758 { 0xa8, 0x03, 0x0d5, 0x35, 0x0d4 },
759 { 0x1d, 0x04, 0x080, 0xa1, 0x889 },
760 { 0x1d, 0x04, 0x081, 0xb1, 0x889 },
761 { 0xe2, 0x0d, 0x080, 0x4e, 0x888 },
762 { 0xe2, 0x0d, 0x081, 0x5e, 0x888 },
763 { 0x45, 0x01, 0x014, 0x22, 0x015 },
764 { 0x45, 0x01, 0x015, 0xa2, 0x81d },
765 { 0xe9, 0x06, 0x080, 0x4b, 0x889 },
766 { 0xe9, 0x06, 0x081, 0x4f, 0x889 },
767 { 0xaa, 0x02, 0x0d4, 0x2a, 0x0d5 },
768 { 0xaa, 0x02, 0x0d5, 0x6a, 0x8dd },
769 { 0x90, 0x01, 0x0c4, 0x48, 0x8cc },
770 { 0x90, 0x01, 0x0c5, 0xc8, 0x0c4 },
771 { 0x63, 0x07, 0x040, 0x8c, 0x849 },
772 { 0x63, 0x07, 0x041, 0x8e, 0x849 },
773 { 0x83, 0x58, 0x080, 0x1a, 0x080 },
774 { 0x83, 0x58, 0x081, 0x1e, 0x080 },
775 { 0x70, 0x58, 0x010, 0x81, 0x819 },
776 { 0x70, 0x58, 0x011, 0x85, 0x819 },
777 { 0xaa, 0x08, 0x090, 0x54, 0x899 },
778 { 0xaa, 0x08, 0x091, 0x55, 0x899 },
779 { 0xb2, 0x09, 0x0c4, 0xb2, 0x8cc },
780 { 0xb2, 0x09, 0x0c5, 0xb2, 0x8cd },
781 { 0x98, 0x01, 0x800, 0x4c, 0x808 },
782 { 0x98, 0x01, 0x801, 0xcc, 0x000 },
783 { 0xff, 0x01, 0x040, 0x7f, 0x849 },
784 { 0xff, 0x01, 0x041, 0xff, 0x041 },
785 { 0x90, 0x09, 0x0c0, 0x90, 0x8c8 },
786 { 0x90, 0x09, 0x0c1, 0x90, 0x8c9 },
787 { 0x53, 0x09, 0x0d0, 0x53, 0x8d8 },
788 { 0x53, 0x09, 0x0d1, 0x53, 0x8d9 },
789 { 0xfc, 0x08, 0x084, 0xf8, 0x085 },
790 { 0xfc, 0x08, 0x085, 0xf9, 0x085 },
791 { 0x41, 0x00, 0x010, 0x41, 0x010 },
792 { 0x41, 0x00, 0x011, 0x41, 0x011 },
793 { 0x5a, 0x01, 0x0d4, 0x2d, 0x0d4 },
794 { 0x5a, 0x01, 0x0d5, 0xad, 0x8dc },
795 { 0xfc, 0x09, 0x080, 0xfc, 0x080 },
796 { 0xfc, 0x09, 0x081, 0xfc, 0x081 },
797 { 0x57, 0x00, 0x800, 0x57, 0x808 },
798 { 0x57, 0x00, 0x801, 0x57, 0x809 },
799 { 0xa2, 0x09, 0x0c4, 0xa2, 0x8cc },
800 { 0xa2, 0x09, 0x0c5, 0xa2, 0x8cd },
801 { 0xde, 0x09, 0x090, 0xde, 0x090 },
802 { 0xde, 0x09, 0x091, 0xde, 0x091 },
803 { 0x2e, 0x09, 0x0d0, 0x2e, 0x0d0 },
804 { 0x2e, 0x09, 0x0d1, 0x2e, 0x0d1 },
805};
806
807const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU16 = 56;
808const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcr_amd_TestDataU16[56] =
809{
810 { 0x0000, 0x0a, 0x084, 0x0000, 0x084 },
811 { 0x0000, 0x0a, 0x085, 0x0040, 0x084 },
812 { 0xffff, 0x06, 0x080, 0xfbff, 0x081 },
813 { 0xffff, 0x06, 0x081, 0xffff, 0x081 },
814 { 0x0000, 0x10, 0x000, 0x0000, 0x000 },
815 { 0x0000, 0x10, 0x001, 0x0001, 0x000 },
816 { 0x0015, 0x02, 0x0c0, 0x8005, 0x8c8 },
817 { 0x0015, 0x02, 0x0c1, 0xc005, 0x0c0 },
818 { 0xdd32, 0x1f, 0x044, 0xe993, 0x044 },
819 { 0xdd32, 0x1f, 0x045, 0xe997, 0x044 },
820 { 0x847a, 0x1f, 0x090, 0x23d2, 0x090 },
821 { 0x847a, 0x1f, 0x091, 0x23d6, 0x090 },
822 { 0x0013, 0x06, 0x044, 0x9800, 0x84c },
823 { 0x0013, 0x06, 0x045, 0x9c00, 0x84c },
824 { 0xdcd9, 0x1f, 0x000, 0xe6cb, 0x000 },
825 { 0xdcd9, 0x1f, 0x001, 0xe6cf, 0x000 },
826 { 0xde45, 0x09, 0x084, 0x456f, 0x88c },
827 { 0xde45, 0x09, 0x085, 0x45ef, 0x88c },
828 { 0x0f89, 0x01, 0x044, 0x07c4, 0x045 },
829 { 0x0f89, 0x01, 0x045, 0x87c4, 0x84d },
830 { 0x884a, 0x0b, 0x004, 0x1291, 0x004 },
831 { 0x884a, 0x0b, 0x005, 0x12b1, 0x004 },
832 { 0x87d0, 0x09, 0x0d0, 0xd043, 0x0d1 },
833 { 0x87d0, 0x09, 0x0d1, 0xd0c3, 0x0d1 },
834 { 0x34c8, 0x1c, 0x044, 0x3206, 0x045 },
835 { 0x34c8, 0x1c, 0x045, 0x3226, 0x045 },
836 { 0x686b, 0x02, 0x0c0, 0x9a1a, 0x8c9 },
837 { 0x686b, 0x02, 0x0c1, 0xda1a, 0x0c1 },
838 { 0xe410, 0x00, 0x080, 0xe410, 0x080 },
839 { 0xe410, 0x00, 0x081, 0xe410, 0x081 },
840 { 0x23c8, 0x11, 0x000, 0x23c8, 0x000 },
841 { 0x23c8, 0x11, 0x001, 0x23c8, 0x001 },
842 { 0xc911, 0x11, 0x084, 0xc911, 0x084 },
843 { 0xc911, 0x11, 0x085, 0xc911, 0x085 },
844 { 0xd674, 0x11, 0x0c4, 0xd674, 0x0c4 },
845 { 0xd674, 0x11, 0x0c5, 0xd674, 0x0c5 },
846 { 0x0581, 0x11, 0x010, 0x0581, 0x010 },
847 { 0x0581, 0x11, 0x011, 0x0581, 0x011 },
848 { 0x1b0e, 0x11, 0x014, 0x1b0e, 0x014 },
849 { 0x1b0e, 0x11, 0x015, 0x1b0e, 0x015 },
850 { 0x915c, 0x11, 0x004, 0x915c, 0x80c },
851 { 0x915c, 0x11, 0x005, 0x915c, 0x80d },
852 { 0x001b, 0x11, 0x090, 0x001b, 0x090 },
853 { 0x001b, 0x11, 0x091, 0x001b, 0x091 },
854 { 0x36ee, 0x11, 0x084, 0x36ee, 0x084 },
855 { 0x36ee, 0x11, 0x085, 0x36ee, 0x085 },
856 { 0x62a8, 0x00, 0x0c4, 0x62a8, 0x0c4 },
857 { 0x62a8, 0x00, 0x0c5, 0x62a8, 0x0c5 },
858 { 0x7e82, 0x10, 0x054, 0xfd04, 0x054 },
859 { 0x7e82, 0x10, 0x055, 0xfd05, 0x054 },
860 { 0x9c63, 0x11, 0x000, 0x9c63, 0x808 },
861 { 0x9c63, 0x11, 0x001, 0x9c63, 0x809 },
862 { 0xbe4a, 0x11, 0x050, 0xbe4a, 0x858 },
863 { 0xbe4a, 0x11, 0x051, 0xbe4a, 0x859 },
864 { 0x0050, 0x11, 0x010, 0x0050, 0x010 },
865 { 0x0050, 0x11, 0x011, 0x0050, 0x011 },
866};
867
868const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU32 = 64;
869const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcr_amd_TestDataU32[64] =
870{
871 { 0x00000000, 0x09, 0x040, 0x00000000, 0x040 },
872 { 0x00000000, 0x09, 0x041, 0x00800000, 0x040 },
873 { 0xffffffff, 0x18, 0x090, 0xfffffeff, 0x091 },
874 { 0xffffffff, 0x18, 0x091, 0xffffffff, 0x091 },
875 { 0x00000000, 0x3a, 0x040, 0x00000000, 0x040 },
876 { 0x00000000, 0x3a, 0x041, 0x00000040, 0x040 },
877 { 0x835debdf, 0x1a, 0x080, 0xaef5efa0, 0x889 },
878 { 0x835debdf, 0x1a, 0x081, 0xaef5efe0, 0x889 },
879 { 0xf812a7f4, 0x17, 0x040, 0x4a9fd1f0, 0x848 },
880 { 0xf812a7f4, 0x17, 0x041, 0x4a9fd3f0, 0x848 },
881 { 0x18526304, 0x09, 0x000, 0x040c2931, 0x001 },
882 { 0x18526304, 0x09, 0x001, 0x048c2931, 0x001 },
883 { 0xde05e7fd, 0x0d, 0x090, 0x7fd6f02f, 0x898 },
884 { 0xde05e7fd, 0x0d, 0x091, 0x7fdef02f, 0x898 },
885 { 0x7fb8aa0a, 0x1a, 0x0d0, 0xdc55051f, 0x0d1 },
886 { 0x7fb8aa0a, 0x1a, 0x0d1, 0xdc55055f, 0x0d1 },
887 { 0x038b1369, 0x04, 0x014, 0x2038b136, 0x015 },
888 { 0x038b1369, 0x04, 0x015, 0x3038b136, 0x015 },
889 { 0x285d080f, 0x1d, 0x054, 0x85d080f1, 0x85c },
890 { 0x285d080f, 0x1d, 0x055, 0x85d080f9, 0x85c },
891 { 0x0002cff9, 0x12, 0x050, 0x67fc8000, 0x859 },
892 { 0x0002cff9, 0x12, 0x051, 0x67fcc000, 0x859 },
893 { 0x2b9a09b6, 0x07, 0x090, 0xd8573413, 0x090 },
894 { 0x2b9a09b6, 0x07, 0x091, 0xda573413, 0x090 },
895 { 0x58fd09b2, 0x2a, 0x004, 0xd9163f42, 0x004 },
896 { 0x58fd09b2, 0x2a, 0x005, 0xd9563f42, 0x004 },
897 { 0xeef70576, 0x0d, 0x894, 0x576777b8, 0x89c },
898 { 0xeef70576, 0x0d, 0x895, 0x576f77b8, 0x89c },
899 { 0x737b0176, 0x19, 0x054, 0x7b017639, 0x85d },
900 { 0x737b0176, 0x19, 0x055, 0x7b0176b9, 0x85d },
901 { 0x00041f4f, 0x01, 0x014, 0x00020fa7, 0x015 },
902 { 0x00041f4f, 0x01, 0x015, 0x80020fa7, 0x81d },
903 { 0x574c7d42, 0x06, 0x084, 0x115d31f5, 0x084 },
904 { 0x574c7d42, 0x06, 0x085, 0x155d31f5, 0x084 },
905 { 0x1c5d3ebc, 0x00, 0x050, 0x1c5d3ebc, 0x050 },
906 { 0x1c5d3ebc, 0x00, 0x051, 0x1c5d3ebc, 0x051 },
907 { 0x4644c175, 0x20, 0x054, 0x4644c175, 0x054 },
908 { 0x4644c175, 0x20, 0x055, 0x4644c175, 0x055 },
909 { 0x38222278, 0x21, 0x840, 0x1c11113c, 0x040 },
910 { 0x38222278, 0x21, 0x841, 0x9c11113c, 0x848 },
911 { 0x000003f9, 0x21, 0x884, 0x000001fc, 0x085 },
912 { 0x000003f9, 0x21, 0x885, 0x800001fc, 0x88d },
913 { 0xe8e4ca2b, 0x21, 0x010, 0x74726515, 0x819 },
914 { 0xe8e4ca2b, 0x21, 0x011, 0xf4726515, 0x011 },
915 { 0xa36c408d, 0x21, 0x010, 0x51b62046, 0x819 },
916 { 0xa36c408d, 0x21, 0x011, 0xd1b62046, 0x011 },
917 { 0x41ac185f, 0x21, 0x0c4, 0x20d60c2f, 0x0c5 },
918 { 0x41ac185f, 0x21, 0x0c5, 0xa0d60c2f, 0x8cd },
919 { 0x757c5e36, 0x21, 0x0c0, 0x3abe2f1b, 0x0c0 },
920 { 0x757c5e36, 0x21, 0x0c1, 0xbabe2f1b, 0x8c8 },
921 { 0x00db0fcc, 0x21, 0x080, 0x006d87e6, 0x080 },
922 { 0x00db0fcc, 0x21, 0x081, 0x806d87e6, 0x888 },
923 { 0x2f70ce8d, 0x21, 0x094, 0x17b86746, 0x095 },
924 { 0x2f70ce8d, 0x21, 0x095, 0x97b86746, 0x89d },
925 { 0xd1383ecc, 0x21, 0x044, 0x689c1f66, 0x84c },
926 { 0xd1383ecc, 0x21, 0x045, 0xe89c1f66, 0x044 },
927 { 0x7c9c640c, 0x21, 0x054, 0x3e4e3206, 0x054 },
928 { 0x7c9c640c, 0x21, 0x055, 0xbe4e3206, 0x85c },
929 { 0x1ce1e618, 0x21, 0x014, 0x0e70f30c, 0x014 },
930 { 0x1ce1e618, 0x21, 0x015, 0x8e70f30c, 0x81c },
931 { 0x00147b5c, 0x21, 0x0c4, 0x000a3dae, 0x0c4 },
932 { 0x00147b5c, 0x21, 0x0c5, 0x800a3dae, 0x8cc },
933 { 0xdd7b22ba, 0x21, 0x084, 0x6ebd915d, 0x88c },
934 { 0xdd7b22ba, 0x21, 0x085, 0xeebd915d, 0x084 },
935};
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