Gitiles
Code Review Sign In
gerrit.witaqua.org / art / 937e6cd515bbe7ff2f255c8fcd40bf1a575a9a16 / . / test / 565-checker-rotate / src / Main.java
blob: aadb5978e85ffc2f390cde00ceb183d729389e49 [file] [log] [blame]
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17public class Main {
18
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]19 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) intrinsics_recognition (after)
20 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
21 /// CHECK: <<ArgVal:z\d+>> ParameterValue
22 /// CHECK: <<ArgDist:i\d+>> ParameterValue
23 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
24 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
25 /// CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
26 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Val>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
27 /// CHECK-DAG: Return [<<Result>>]
28
29 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier (after)
30 /// CHECK: <<ArgVal:z\d+>> ParameterValue
31 /// CHECK: <<ArgDist:i\d+>> ParameterValue
32 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
33 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
34 /// CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
35 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
36 /// CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<NegDist>>]
37 /// CHECK-DAG: Return [<<Result>>]
38
39 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier (after)
40 /// CHECK-NOT: InvokeStaticOrDirect
41
42 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
43 /// CHECK: <<ArgVal:z\d+>> ParameterValue
44 /// CHECK: <<ArgDist:i\d+>> ParameterValue
45 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
46 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
47 /// CHECK-DAG: <<SelVal:i\d+>> Select [<<Zero>>,<<One>>,<<ArgVal>>]
48 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
49 /// CHECK-DAG: <<Result:i\d+>> Ror [<<SelVal>>,<<NegDist>>]
50 /// CHECK-DAG: Return [<<Result>>]
51
52 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) select_generator (after)
53 /// CHECK-NOT: Phi
54
55 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier_after_bce (after)
56 /// CHECK: <<ArgVal:z\d+>> ParameterValue
57 /// CHECK: <<ArgDist:i\d+>> ParameterValue
58 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
59 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
60 /// CHECK-DAG: Return [<<Result>>]
61
62 /// CHECK-START: int Main.rotateLeftBoolean(boolean, int) instruction_simplifier_after_bce (after)
63 /// CHECK-NOT: Select
64
65 private static int rotateLeftBoolean(boolean value, int distance) {
66 return Integer.rotateLeft(value ? 1 : 0, distance);
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]67 }
68
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]69 /// CHECK-START: int Main.rotateLeftByte(byte, int) intrinsics_recognition (after)
70 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
71 /// CHECK: <<ArgVal:b\d+>> ParameterValue
72 /// CHECK: <<ArgDist:i\d+>> ParameterValue
73 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
74 /// CHECK-DAG: Return [<<Result>>]
75
76 /// CHECK-START: int Main.rotateLeftByte(byte, int) instruction_simplifier (after)
77 /// CHECK: <<ArgVal:b\d+>> ParameterValue
78 /// CHECK: <<ArgDist:i\d+>> ParameterValue
79 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
80 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
81 /// CHECK-DAG: Return [<<Result>>]
82
83 /// CHECK-START: int Main.rotateLeftByte(byte, int) instruction_simplifier (after)
84 /// CHECK-NOT: InvokeStaticOrDirect
85
86 private static int rotateLeftByte(byte value, int distance) {
87 return Integer.rotateLeft(value, distance);
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]88 }
89
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]90 /// CHECK-START: int Main.rotateLeftShort(short, int) intrinsics_recognition (after)
91 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
92 /// CHECK: <<ArgVal:s\d+>> ParameterValue
93 /// CHECK: <<ArgDist:i\d+>> ParameterValue
94 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
95 /// CHECK-DAG: Return [<<Result>>]
96
97 /// CHECK-START: int Main.rotateLeftShort(short, int) instruction_simplifier (after)
98 /// CHECK: <<ArgVal:s\d+>> ParameterValue
99 /// CHECK: <<ArgDist:i\d+>> ParameterValue
100 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
101 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
102 /// CHECK-DAG: Return [<<Result>>]
103
104 /// CHECK-START: int Main.rotateLeftShort(short, int) instruction_simplifier (after)
105 /// CHECK-NOT: InvokeStaticOrDirect
106
107 private static int rotateLeftShort(short value, int distance) {
108 return Integer.rotateLeft(value, distance);
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]109 }
110
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]111 /// CHECK-START: int Main.rotateLeftChar(char, int) intrinsics_recognition (after)
112 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
113 /// CHECK: <<ArgVal:c\d+>> ParameterValue
114 /// CHECK: <<ArgDist:i\d+>> ParameterValue
115 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
116 /// CHECK-DAG: Return [<<Result>>]
117
118 /// CHECK-START: int Main.rotateLeftChar(char, int) instruction_simplifier (after)
119 /// CHECK: <<ArgVal:c\d+>> ParameterValue
120 /// CHECK: <<ArgDist:i\d+>> ParameterValue
121 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
122 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
123 /// CHECK-DAG: Return [<<Result>>]
124
125 /// CHECK-START: int Main.rotateLeftChar(char, int) instruction_simplifier (after)
126 /// CHECK-NOT: InvokeStaticOrDirect
127
128 private static int rotateLeftChar(char value, int distance) {
129 return Integer.rotateLeft(value, distance);
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]130 }
131
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]132 /// CHECK-START: int Main.rotateLeftInt(int, int) intrinsics_recognition (after)
133 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
134 /// CHECK: <<ArgVal:i\d+>> ParameterValue
135 /// CHECK: <<ArgDist:i\d+>> ParameterValue
136 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
137 /// CHECK-DAG: Return [<<Result>>]
138
139 /// CHECK-START: int Main.rotateLeftInt(int, int) instruction_simplifier (after)
140 /// CHECK: <<ArgVal:i\d+>> ParameterValue
141 /// CHECK: <<ArgDist:i\d+>> ParameterValue
142 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
143 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
144 /// CHECK-DAG: Return [<<Result>>]
145
146 /// CHECK-START: int Main.rotateLeftInt(int, int) instruction_simplifier (after)
147 /// CHECK-NOT: InvokeStaticOrDirect
148
149 private static int rotateLeftInt(int value, int distance) {
150 return Integer.rotateLeft(value, distance);
151 }
152
153 /// CHECK-START: long Main.rotateLeftLong(long, int) intrinsics_recognition (after)
154 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
155 /// CHECK: <<ArgVal:j\d+>> ParameterValue
156 /// CHECK: <<ArgDist:i\d+>> ParameterValue
157 /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:LongRotateLeft
158 /// CHECK-DAG: Return [<<Result>>]
159
160 /// CHECK-START: long Main.rotateLeftLong(long, int) instruction_simplifier (after)
161 /// CHECK: <<ArgVal:j\d+>> ParameterValue
162 /// CHECK: <<ArgDist:i\d+>> ParameterValue
163 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
164 /// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<NegDist>>]
165 /// CHECK-DAG: Return [<<Result>>]
166
167 /// CHECK-START: long Main.rotateLeftLong(long, int) instruction_simplifier (after)
168 /// CHECK-NOT: InvokeStaticOrDirect
169
170 private static long rotateLeftLong(long value, int distance) {
171 return Long.rotateLeft(value, distance);
172 }
173
174
175 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) intrinsics_recognition (after)
176 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
177 /// CHECK: <<ArgVal:z\d+>> ParameterValue
178 /// CHECK: <<ArgDist:i\d+>> ParameterValue
179 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
180 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
181 /// CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
182 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Val>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
183 /// CHECK-DAG: Return [<<Result>>]
184
185 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier (after)
186 /// CHECK: <<ArgVal:z\d+>> ParameterValue
187 /// CHECK: <<ArgDist:i\d+>> ParameterValue
188 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
189 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
190 /// CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
191 /// CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<ArgDist>>]
192 /// CHECK-DAG: Return [<<Result>>]
193
194 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier (after)
195 /// CHECK-NOT: InvokeStaticOrDirect
196
197 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
198 /// CHECK: <<ArgVal:z\d+>> ParameterValue
199 /// CHECK: <<ArgDist:i\d+>> ParameterValue
200 /// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
201 /// CHECK-DAG: <<One:i\d+>> IntConstant 1
202 /// CHECK-DAG: <<SelVal:i\d+>> Select [<<Zero>>,<<One>>,<<ArgVal>>]
203 /// CHECK-DAG: <<Result:i\d+>> Ror [<<SelVal>>,<<ArgDist>>]
204 /// CHECK-DAG: Return [<<Result>>]
205
206 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) select_generator (after)
207 /// CHECK-NOT: Phi
208
209 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier_after_bce (after)
210 /// CHECK: <<ArgVal:z\d+>> ParameterValue
211 /// CHECK: <<ArgDist:i\d+>> ParameterValue
212 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
213 /// CHECK-DAG: Return [<<Result>>]
214
215 /// CHECK-START: int Main.rotateRightBoolean(boolean, int) instruction_simplifier_after_bce (after)
216 /// CHECK-NOT: Select
217
218 private static int rotateRightBoolean(boolean value, int distance) {
219 return Integer.rotateRight(value ? 1 : 0, distance);
220 }
221
222 /// CHECK-START: int Main.rotateRightByte(byte, int) intrinsics_recognition (after)
223 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
224 /// CHECK: <<ArgVal:b\d+>> ParameterValue
225 /// CHECK: <<ArgDist:i\d+>> ParameterValue
226 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
227 /// CHECK-DAG: Return [<<Result>>]
228
229 /// CHECK-START: int Main.rotateRightByte(byte, int) instruction_simplifier (after)
230 /// CHECK: <<ArgVal:b\d+>> ParameterValue
231 /// CHECK: <<ArgDist:i\d+>> ParameterValue
232 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
233 /// CHECK-DAG: Return [<<Result>>]
234
235 /// CHECK-START: int Main.rotateRightByte(byte, int) instruction_simplifier (after)
236 /// CHECK-NOT: InvokeStaticOrDirect
237
238 private static int rotateRightByte(byte value, int distance) {
239 return Integer.rotateRight(value, distance);
240 }
241
242 /// CHECK-START: int Main.rotateRightShort(short, int) intrinsics_recognition (after)
243 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
244 /// CHECK: <<ArgVal:s\d+>> ParameterValue
245 /// CHECK: <<ArgDist:i\d+>> ParameterValue
246 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
247 /// CHECK-DAG: Return [<<Result>>]
248
249 /// CHECK-START: int Main.rotateRightShort(short, int) instruction_simplifier (after)
250 /// CHECK: <<ArgVal:s\d+>> ParameterValue
251 /// CHECK: <<ArgDist:i\d+>> ParameterValue
252 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
253 /// CHECK-DAG: Return [<<Result>>]
254
255 /// CHECK-START: int Main.rotateRightShort(short, int) instruction_simplifier (after)
256 /// CHECK-NOT: InvokeStaticOrDirect
257
258 private static int rotateRightShort(short value, int distance) {
259 return Integer.rotateRight(value, distance);
260 }
261
262 /// CHECK-START: int Main.rotateRightChar(char, int) intrinsics_recognition (after)
263 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
264 /// CHECK: <<ArgVal:c\d+>> ParameterValue
265 /// CHECK: <<ArgDist:i\d+>> ParameterValue
266 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
267 /// CHECK-DAG: Return [<<Result>>]
268
269 /// CHECK-START: int Main.rotateRightChar(char, int) instruction_simplifier (after)
270 /// CHECK: <<ArgVal:c\d+>> ParameterValue
271 /// CHECK: <<ArgDist:i\d+>> ParameterValue
272 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
273 /// CHECK-DAG: Return [<<Result>>]
274
275 /// CHECK-START: int Main.rotateRightChar(char, int) instruction_simplifier (after)
276 /// CHECK-NOT: InvokeStaticOrDirect
277
278 private static int rotateRightChar(char value, int distance) {
279 return Integer.rotateRight(value, distance);
280 }
281
282 /// CHECK-START: int Main.rotateRightInt(int, int) intrinsics_recognition (after)
283 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
284 /// CHECK: <<ArgVal:i\d+>> ParameterValue
285 /// CHECK: <<ArgDist:i\d+>> ParameterValue
286 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
287 /// CHECK-DAG: Return [<<Result>>]
288
289 /// CHECK-START: int Main.rotateRightInt(int, int) instruction_simplifier (after)
290 /// CHECK: <<ArgVal:i\d+>> ParameterValue
291 /// CHECK: <<ArgDist:i\d+>> ParameterValue
292 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
293 /// CHECK-DAG: Return [<<Result>>]
294
295 /// CHECK-START: int Main.rotateRightInt(int, int) instruction_simplifier (after)
296 /// CHECK-NOT: InvokeStaticOrDirect
297
298 private static int rotateRightInt(int value, int distance) {
299 return Integer.rotateRight(value, distance);
300 }
301
302 /// CHECK-START: long Main.rotateRightLong(long, int) intrinsics_recognition (after)
303 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
304 /// CHECK: <<ArgVal:j\d+>> ParameterValue
305 /// CHECK: <<ArgDist:i\d+>> ParameterValue
306 /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:LongRotateRight
307 /// CHECK-DAG: Return [<<Result>>]
308
309 /// CHECK-START: long Main.rotateRightLong(long, int) instruction_simplifier (after)
310 /// CHECK: <<ArgVal:j\d+>> ParameterValue
311 /// CHECK: <<ArgDist:i\d+>> ParameterValue
312 /// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
313 /// CHECK-DAG: Return [<<Result>>]
314
315 /// CHECK-START: long Main.rotateRightLong(long, int) instruction_simplifier (after)
316 /// CHECK-NOT: InvokeStaticOrDirect
317
318 private static long rotateRightLong(long value, int distance) {
319 return Long.rotateRight(value, distance);
320 }
321
322
Roland Levillain937e6cd2016-03-22 11:54:37 +0000[diff] [blame^]323 /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) intrinsics_recognition (after)
324 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
325 /// CHECK: <<ArgVal:i\d+>> ParameterValue
326 /// CHECK: <<ArgDist:b\d+>> ParameterValue
327 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateLeft
328 /// CHECK-DAG: Return [<<Result>>]
329
330 /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) instruction_simplifier (after)
331 /// CHECK: <<ArgVal:i\d+>> ParameterValue
332 /// CHECK: <<ArgDist:b\d+>> ParameterValue
333 /// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
334 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
335 /// CHECK-DAG: Return [<<Result>>]
336
337 /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) instruction_simplifier (after)
338 /// CHECK-NOT: InvokeStaticOrDirect
339
340 private static int rotateLeftIntWithByteDistance(int value, byte distance) {
341 return Integer.rotateLeft(value, distance);
342 }
343
344 /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) intrinsics_recognition (after)
345 /// CHECK-DAG: <<Method:[ij]\d+>> CurrentMethod
346 /// CHECK: <<ArgVal:i\d+>> ParameterValue
347 /// CHECK: <<ArgDist:b\d+>> ParameterValue
348 /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>,<<Method>>] intrinsic:IntegerRotateRight
349 /// CHECK-DAG: Return [<<Result>>]
350
351 /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) instruction_simplifier (after)
352 /// CHECK: <<ArgVal:i\d+>> ParameterValue
353 /// CHECK: <<ArgDist:b\d+>> ParameterValue
354 /// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
355 /// CHECK-DAG: Return [<<Result>>]
356
357 /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) instruction_simplifier (after)
358 /// CHECK-NOT: InvokeStaticOrDirect
359
360 private static int rotateRightIntWithByteDistance(int value, byte distance) {
361 return Integer.rotateRight(value, distance);
362 }
363
364
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]365 public static void testRotateLeftBoolean() {
366 for (int i = 0; i < 40; i++) { // overshoot a bit
367 int j = i & 31;
368 expectEqualsInt(0, rotateLeftBoolean(false, i));
369 expectEqualsInt(1 << i, rotateLeftBoolean(true, i));
370 }
371 }
372
373 public static void testRotateLeftByte() {
374 expectEqualsInt(0x00000001, rotateLeftByte((byte)0x01, 0));
375 expectEqualsInt(0x00000002, rotateLeftByte((byte)0x01, 1));
376 expectEqualsInt(0x80000000, rotateLeftByte((byte)0x01, 31));
377 expectEqualsInt(0x00000001, rotateLeftByte((byte)0x01, 32)); // overshoot
378 expectEqualsInt(0xFFFFFF03, rotateLeftByte((byte)0x81, 1));
379 expectEqualsInt(0xFFFFFE07, rotateLeftByte((byte)0x81, 2));
380 expectEqualsInt(0x00000120, rotateLeftByte((byte)0x12, 4));
381 expectEqualsInt(0xFFFF9AFF, rotateLeftByte((byte)0x9A, 8));
382 for (int i = 0; i < 40; i++) { // overshoot a bit
383 int j = i & 31;
384 expectEqualsInt(0x00000000, rotateLeftByte((byte)0x0000, i));
385 expectEqualsInt(0xFFFFFFFF, rotateLeftByte((byte)0xFFFF, i));
386 expectEqualsInt((1 << j), rotateLeftByte((byte)0x0001, i));
387 expectEqualsInt((0x12 << j) | (0x12 >>> -j), rotateLeftByte((byte)0x12, i));
388 }
389 }
390
391 public static void testRotateLeftShort() {
392 expectEqualsInt(0x00000001, rotateLeftShort((short)0x0001, 0));
393 expectEqualsInt(0x00000002, rotateLeftShort((short)0x0001, 1));
394 expectEqualsInt(0x80000000, rotateLeftShort((short)0x0001, 31));
395 expectEqualsInt(0x00000001, rotateLeftShort((short)0x0001, 32)); // overshoot
396 expectEqualsInt(0xFFFF0003, rotateLeftShort((short)0x8001, 1));
397 expectEqualsInt(0xFFFE0007, rotateLeftShort((short)0x8001, 2));
398 expectEqualsInt(0x00012340, rotateLeftShort((short)0x1234, 4));
399 expectEqualsInt(0xFF9ABCFF, rotateLeftShort((short)0x9ABC, 8));
400 for (int i = 0; i < 40; i++) { // overshoot a bit
401 int j = i & 31;
402 expectEqualsInt(0x00000000, rotateLeftShort((short)0x0000, i));
403 expectEqualsInt(0xFFFFFFFF, rotateLeftShort((short)0xFFFF, i));
404 expectEqualsInt((1 << j), rotateLeftShort((short)0x0001, i));
405 expectEqualsInt((0x1234 << j) | (0x1234 >>> -j), rotateLeftShort((short)0x1234, i));
406 }
407 }
408
409 public static void testRotateLeftChar() {
410 expectEqualsInt(0x00000001, rotateLeftChar((char)0x0001, 0));
411 expectEqualsInt(0x00000002, rotateLeftChar((char)0x0001, 1));
412 expectEqualsInt(0x80000000, rotateLeftChar((char)0x0001, 31));
413 expectEqualsInt(0x00000001, rotateLeftChar((char)0x0001, 32)); // overshoot
414 expectEqualsInt(0x00010002, rotateLeftChar((char)0x8001, 1));
415 expectEqualsInt(0x00020004, rotateLeftChar((char)0x8001, 2));
416 expectEqualsInt(0x00012340, rotateLeftChar((char)0x1234, 4));
417 expectEqualsInt(0x009ABC00, rotateLeftChar((char)0x9ABC, 8));
418 expectEqualsInt(0x00FF0000, rotateLeftChar((char)0xFF00, 8));
419 for (int i = 0; i < 40; i++) { // overshoot a bit
420 int j = i & 31;
421 expectEqualsInt(0x00000000, rotateLeftChar((char)0x0000, i));
422 expectEqualsInt((1 << j), rotateLeftChar((char)0x0001, i));
423 expectEqualsInt((0x1234 << j) | (0x1234 >>> -j), rotateLeftChar((char)0x1234, i));
424 }
425 }
426
427 public static void testRotateLeftInt() {
428 expectEqualsInt(0x00000001, rotateLeftInt(0x00000001, 0));
429 expectEqualsInt(0x00000002, rotateLeftInt(0x00000001, 1));
430 expectEqualsInt(0x80000000, rotateLeftInt(0x00000001, 31));
431 expectEqualsInt(0x00000001, rotateLeftInt(0x00000001, 32)); // overshoot
432 expectEqualsInt(0x00000003, rotateLeftInt(0x80000001, 1));
433 expectEqualsInt(0x00000006, rotateLeftInt(0x80000001, 2));
434 expectEqualsInt(0x23456781, rotateLeftInt(0x12345678, 4));
435 expectEqualsInt(0xBCDEF09A, rotateLeftInt(0x9ABCDEF0, 8));
436 for (int i = 0; i < 40; i++) { // overshoot a bit
437 int j = i & 31;
438 expectEqualsInt(0x00000000, rotateLeftInt(0x00000000, i));
439 expectEqualsInt(0xFFFFFFFF, rotateLeftInt(0xFFFFFFFF, i));
440 expectEqualsInt(1 << j, rotateLeftInt(0x00000001, i));
441 expectEqualsInt((0x12345678 << j) | (0x12345678 >>> -j), rotateLeftInt(0x12345678, i));
442 }
443 }
444
445 public static void testRotateLeftLong() {
446 expectEqualsLong(0x0000000000000001L, rotateLeftLong(0x0000000000000001L, 0));
447 expectEqualsLong(0x0000000000000002L, rotateLeftLong(0x0000000000000001L, 1));
448 expectEqualsLong(0x8000000000000000L, rotateLeftLong(0x0000000000000001L, 63));
449 expectEqualsLong(0x0000000000000001L, rotateLeftLong(0x0000000000000001L, 64)); // overshoot
450 expectEqualsLong(0x0000000000000003L, rotateLeftLong(0x8000000000000001L, 1));
451 expectEqualsLong(0x0000000000000006L, rotateLeftLong(0x8000000000000001L, 2));
452 expectEqualsLong(0x23456789ABCDEF01L, rotateLeftLong(0x123456789ABCDEF0L, 4));
453 expectEqualsLong(0x3456789ABCDEF012L, rotateLeftLong(0x123456789ABCDEF0L, 8));
454 for (int i = 0; i < 70; i++) { // overshoot a bit
455 int j = i & 63;
456 expectEqualsLong(0x0000000000000000L, rotateLeftLong(0x0000000000000000L, i));
457 expectEqualsLong(0xFFFFFFFFFFFFFFFFL, rotateLeftLong(0xFFFFFFFFFFFFFFFFL, i));
458 expectEqualsLong(1L << j, rotateLeftLong(0x0000000000000001, i));
459 expectEqualsLong((0x123456789ABCDEF0L << j) | (0x123456789ABCDEF0L >>> -j),
460 rotateLeftLong(0x123456789ABCDEF0L, i));
461 }
462 }
463
464 public static void testRotateRightBoolean() {
465 for (int i = 0; i < 40; i++) { // overshoot a bit
466 int j = i & 31;
467 expectEqualsInt(0, rotateRightBoolean(false, i));
468 expectEqualsInt(1 << (32 - i), rotateRightBoolean(true, i));
469 }
470 }
471
472 public static void testRotateRightByte() {
473 expectEqualsInt(0xFFFFFF80, rotateRightByte((byte)0x80, 0));
474 expectEqualsInt(0x7FFFFFC0, rotateRightByte((byte)0x80, 1));
475 expectEqualsInt(0xFFFFFF01, rotateRightByte((byte)0x80, 31));
476 expectEqualsInt(0xFFFFFF80, rotateRightByte((byte)0x80, 32)); // overshoot
477 expectEqualsInt(0xFFFFFFC0, rotateRightByte((byte)0x81, 1));
478 expectEqualsInt(0x7FFFFFE0, rotateRightByte((byte)0x81, 2));
479 expectEqualsInt(0x20000001, rotateRightByte((byte)0x12, 4));
480 expectEqualsInt(0x9AFFFFFF, rotateRightByte((byte)0x9A, 8));
481 for (int i = 0; i < 40; i++) { // overshoot a bit
482 int j = i & 31;
483 expectEqualsInt(0x00000000, rotateRightByte((byte)0x00, i));
484 expectEqualsInt(0xFFFFFFFF, rotateRightByte((byte)0xFF, i));
485 expectEqualsInt(1 << (32 - j), rotateRightByte((byte)0x01, i));
486 expectEqualsInt((0x12 >>> j) | (0x12 << -j), rotateRightByte((byte)0x12, i));
487 }
488 }
489
490 public static void testRotateRightShort() {
491 expectEqualsInt(0xFFFF8000, rotateRightShort((short)0x8000, 0));
492 expectEqualsInt(0x7FFFC000, rotateRightShort((short)0x8000, 1));
493 expectEqualsInt(0xFFFF0001, rotateRightShort((short)0x8000, 31));
494 expectEqualsInt(0xFFFF8000, rotateRightShort((short)0x8000, 32)); // overshoot
495 expectEqualsInt(0xFFFFC000, rotateRightShort((short)0x8001, 1));
496 expectEqualsInt(0x7FFFE000, rotateRightShort((short)0x8001, 2));
497 expectEqualsInt(0x40000123, rotateRightShort((short)0x1234, 4));
498 expectEqualsInt(0xBCFFFF9A, rotateRightShort((short)0x9ABC, 8));
499 for (int i = 0; i < 40; i++) { // overshoot a bit
500 int j = i & 31;
501 expectEqualsInt(0x00000000, rotateRightShort((short)0x0000, i));
502 expectEqualsInt(0xFFFFFFFF, rotateRightShort((short)0xFFFF, i));
503 expectEqualsInt(1 << (32 - j), rotateRightShort((short)0x0001, i));
504 expectEqualsInt((0x1234 >>> j) | (0x1234 << -j), rotateRightShort((short)0x1234, i));
505 }
506 }
507
508 public static void testRotateRightChar() {
509 expectEqualsInt(0x00008000, rotateRightChar((char)0x8000, 0));
510 expectEqualsInt(0x00004000, rotateRightChar((char)0x8000, 1));
511 expectEqualsInt(0x00010000, rotateRightChar((char)0x8000, 31));
512 expectEqualsInt(0x00008000, rotateRightChar((char)0x8000, 32)); // overshoot
513 expectEqualsInt(0x80004000, rotateRightChar((char)0x8001, 1));
514 expectEqualsInt(0x40002000, rotateRightChar((char)0x8001, 2));
515 expectEqualsInt(0x40000123, rotateRightChar((char)0x1234, 4));
516 expectEqualsInt(0xBC00009A, rotateRightChar((char)0x9ABC, 8));
517 for (int i = 0; i < 40; i++) { // overshoot a bit
518 int j = i & 31;
519 expectEqualsInt(0x00000000, rotateRightChar((char)0x0000, i));
520 expectEqualsInt(1 << (32 - j), rotateRightChar((char)0x0001, i));
521 expectEqualsInt((0x1234 >>> j) | (0x1234 << -j), rotateRightChar((char)0x1234, i));
522 }
523 }
524
525 public static void testRotateRightInt() {
526 expectEqualsInt(0x80000000, rotateRightInt(0x80000000, 0));
527 expectEqualsInt(0x40000000, rotateRightInt(0x80000000, 1));
528 expectEqualsInt(0x00000001, rotateRightInt(0x80000000, 31));
529 expectEqualsInt(0x80000000, rotateRightInt(0x80000000, 32)); // overshoot
530 expectEqualsInt(0xC0000000, rotateRightInt(0x80000001, 1));
531 expectEqualsInt(0x60000000, rotateRightInt(0x80000001, 2));
532 expectEqualsInt(0x81234567, rotateRightInt(0x12345678, 4));
533 expectEqualsInt(0xF09ABCDE, rotateRightInt(0x9ABCDEF0, 8));
534 for (int i = 0; i < 40; i++) { // overshoot a bit
535 int j = i & 31;
536 expectEqualsInt(0x00000000, rotateRightInt(0x00000000, i));
537 expectEqualsInt(0xFFFFFFFF, rotateRightInt(0xFFFFFFFF, i));
538 expectEqualsInt(0x80000000 >>> j, rotateRightInt(0x80000000, i));
539 expectEqualsInt((0x12345678 >>> j) | (0x12345678 << -j), rotateRightInt(0x12345678, i));
540 }
541 }
542
543 public static void testRotateRightLong() {
544 expectEqualsLong(0x8000000000000000L, rotateRightLong(0x8000000000000000L, 0));
545 expectEqualsLong(0x4000000000000000L, rotateRightLong(0x8000000000000000L, 1));
546 expectEqualsLong(0x0000000000000001L, rotateRightLong(0x8000000000000000L, 63));
547 expectEqualsLong(0x8000000000000000L, rotateRightLong(0x8000000000000000L, 64)); // overshoot
548 expectEqualsLong(0xC000000000000000L, rotateRightLong(0x8000000000000001L, 1));
549 expectEqualsLong(0x6000000000000000L, rotateRightLong(0x8000000000000001L, 2));
550 expectEqualsLong(0x0123456789ABCDEFL, rotateRightLong(0x123456789ABCDEF0L, 4));
551 expectEqualsLong(0xF0123456789ABCDEL, rotateRightLong(0x123456789ABCDEF0L, 8));
552 for (int i = 0; i < 70; i++) { // overshoot a bit
553 int j = i & 63;
554 expectEqualsLong(0x0000000000000000L, rotateRightLong(0x0000000000000000L, i));
555 expectEqualsLong(0xFFFFFFFFFFFFFFFFL, rotateRightLong(0xFFFFFFFFFFFFFFFFL, i));
556 expectEqualsLong(0x8000000000000000L >>> j, rotateRightLong(0x8000000000000000L, i));
557 expectEqualsLong((0x123456789ABCDEF0L >>> j) | (0x123456789ABCDEF0L << -j),
558 rotateRightLong(0x123456789ABCDEF0L, i));
559 }
560 }
561
562
Roland Levillain937e6cd2016-03-22 11:54:37 +0000[diff] [blame^]563 public static void testRotateLeftIntWithByteDistance() {
564 expectEqualsInt(0x00000001, rotateLeftIntWithByteDistance(0x00000001, (byte)0));
565 expectEqualsInt(0x00000002, rotateLeftIntWithByteDistance(0x00000001, (byte)1));
566 expectEqualsInt(0x80000000, rotateLeftIntWithByteDistance(0x00000001, (byte)31));
567 expectEqualsInt(0x00000001, rotateLeftIntWithByteDistance(0x00000001, (byte)32)); // overshoot
568 expectEqualsInt(0x00000003, rotateLeftIntWithByteDistance(0x80000001, (byte)1));
569 expectEqualsInt(0x00000006, rotateLeftIntWithByteDistance(0x80000001, (byte)2));
570 expectEqualsInt(0x23456781, rotateLeftIntWithByteDistance(0x12345678, (byte)4));
571 expectEqualsInt(0xBCDEF09A, rotateLeftIntWithByteDistance(0x9ABCDEF0, (byte)8));
572 for (byte i = 0; i < 40; i++) { // overshoot a bit
573 byte j = (byte)(i & 31);
574 expectEqualsInt(0x00000000, rotateLeftIntWithByteDistance(0x00000000, i));
575 expectEqualsInt(0xFFFFFFFF, rotateLeftIntWithByteDistance(0xFFFFFFFF, i));
576 expectEqualsInt(1 << j, rotateLeftIntWithByteDistance(0x00000001, i));
577 expectEqualsInt((0x12345678 << j) | (0x12345678 >>> -j),
578 rotateLeftIntWithByteDistance(0x12345678, i));
579 }
580 }
581
582 public static void testRotateRightIntWithByteDistance() {
583 expectEqualsInt(0x80000000, rotateRightIntWithByteDistance(0x80000000, (byte)0));
584 expectEqualsInt(0x40000000, rotateRightIntWithByteDistance(0x80000000, (byte)1));
585 expectEqualsInt(0x00000001, rotateRightIntWithByteDistance(0x80000000, (byte)31));
586 expectEqualsInt(0x80000000, rotateRightIntWithByteDistance(0x80000000, (byte)32)); // overshoot
587 expectEqualsInt(0xC0000000, rotateRightIntWithByteDistance(0x80000001, (byte)1));
588 expectEqualsInt(0x60000000, rotateRightIntWithByteDistance(0x80000001, (byte)2));
589 expectEqualsInt(0x81234567, rotateRightIntWithByteDistance(0x12345678, (byte)4));
590 expectEqualsInt(0xF09ABCDE, rotateRightIntWithByteDistance(0x9ABCDEF0, (byte)8));
591 for (byte i = 0; i < 40; i++) { // overshoot a bit
592 byte j = (byte)(i & 31);
593 expectEqualsInt(0x00000000, rotateRightIntWithByteDistance(0x00000000, i));
594 expectEqualsInt(0xFFFFFFFF, rotateRightIntWithByteDistance(0xFFFFFFFF, i));
595 expectEqualsInt(0x80000000 >>> j, rotateRightIntWithByteDistance(0x80000000, i));
596 expectEqualsInt((0x12345678 >>> j) | (0x12345678 << -j),
597 rotateRightIntWithByteDistance(0x12345678, i));
598 }
599 }
600
601
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]602 public static void main(String args[]) {
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]603 testRotateLeftBoolean();
604 testRotateLeftByte();
605 testRotateLeftShort();
606 testRotateLeftChar();
607 testRotateLeftInt();
608 testRotateLeftLong();
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]609
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]610 testRotateRightBoolean();
611 testRotateRightByte();
612 testRotateRightShort();
613 testRotateRightChar();
614 testRotateRightInt();
615 testRotateRightLong();
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]616
Roland Levillain937e6cd2016-03-22 11:54:37 +0000[diff] [blame^]617 // Also exercise distance values with types other than int.
618 testRotateLeftIntWithByteDistance();
619 testRotateRightIntWithByteDistance();
620
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]621 System.out.println("passed");
622 }
623
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]624
625 private static void expectEqualsInt(int expected, int result) {
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]626 if (expected != result) {
627 throw new Error("Expected: " + expected + ", found: " + result);
628 }
629 }
Roland Levillain22c49222016-03-18 14:04:28 +0000[diff] [blame]630
631 private static void expectEqualsLong(long expected, long result) {
Aart Bik6e74fa92016-01-25 16:51:32 -0800[diff] [blame]632 if (expected != result) {
633 throw new Error("Expected: " + expected + ", found: " + result);
634 }
635 }
636}