Gitiles
Code Review Sign In
review.blissroms.org / platform_art / 5db109bc8030858f2830f4217333768c3c77095f / . / test / 557-checker-instruction-simplifier-ror / src / Main.java
blob: 310611bba9b2f17319291a5f2ed0f42a5adde729 [file] [log] [blame]
Scott Wakeling40a04bf2015-12-11 09:50:36 +0000[diff] [blame]1/*
2 * Copyright (C) 2015 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
19 public static void assertIntEquals(int expected, int actual) {
20 if (expected != actual) {
21 throw new Error("Expected: " + expected + ", found: " + actual);
22 }
23 }
24
25 public static void assertLongEquals(long expected, long actual) {
26 if (expected != actual) {
27 throw new Error("Expected: " + expected + ", found: " + actual);
28 }
29 }
30
31 /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (before)
32 /// CHECK: <<ArgValue:i\d+>> ParameterValue
33 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
34 /// CHECK: <<Invoke:i\d+>> InvokeStaticOrDirect intrinsic:IntegerRotateRight
35
36 /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (after)
37 /// CHECK: <<ArgValue:i\d+>> ParameterValue
38 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
39 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
40 /// CHECK: Return [<<Ror>>]
41
42 /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (after)
43 /// CHECK-NOT: LoadClass
44 /// CHECK-NOT: ClinitCheck
45 /// CHECK-NOT: InvokeStaticOrDirect
46 public static int rotateIntegerRight(int value, int distance) {
47 return java.lang.Integer.rotateRight(value, distance);
48 }
49
50 /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (before)
51 /// CHECK: <<ArgValue:i\d+>> ParameterValue
52 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
53 /// CHECK: <<Invoke:i\d+>> InvokeStaticOrDirect intrinsic:IntegerRotateLeft
54
55 /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (after)
56 /// CHECK: <<ArgValue:i\d+>> ParameterValue
57 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
58 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
59 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Neg>>]
60 /// CHECK: Return [<<Ror>>]
61
62 /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (after)
63 /// CHECK-NOT: LoadClass
64 /// CHECK-NOT: ClinitCheck
65 /// CHECK-NOT: InvokeStaticOrDirect
66 public static int rotateIntegerLeft(int value, int distance) {
67 return java.lang.Integer.rotateLeft(value, distance);
68 }
69
70 /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (before)
71 /// CHECK: <<ArgValue:j\d+>> ParameterValue
72 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
73 /// CHECK: <<Invoke:j\d+>> InvokeStaticOrDirect intrinsic:LongRotateRight
74
75 /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (after)
76 /// CHECK: <<ArgValue:j\d+>> ParameterValue
77 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
78 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
79 /// CHECK: Return [<<Ror>>]
80
81 /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (after)
82 /// CHECK-NOT: LoadClass
83 /// CHECK-NOT: ClinitCheck
84 /// CHECK-NOT: InvokeStaticOrDirect
85 public static long rotateLongRight(long value, int distance) {
86 return java.lang.Long.rotateRight(value, distance);
87 }
88
89 /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (before)
90 /// CHECK: <<ArgValue:j\d+>> ParameterValue
91 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
92 /// CHECK: <<Invoke:j\d+>> InvokeStaticOrDirect intrinsic:LongRotateLeft
93
94 /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (after)
95 /// CHECK: <<ArgValue:j\d+>> ParameterValue
96 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
97 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
98 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
99 /// CHECK: Return [<<Ror>>]
100
101 /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (after)
102 /// CHECK-NOT: LoadClass
103 /// CHECK-NOT: ClinitCheck
104 /// CHECK-NOT: InvokeStaticOrDirect
105 public static long rotateLongLeft(long value, int distance) {
106 return java.lang.Long.rotateLeft(value, distance);
107 }
108
109 // (i >>> #distance) | (i << #(reg_bits - distance))
110
111 /// CHECK-START: int Main.ror_int_constant_c_c(int) instruction_simplifier (before)
112 /// CHECK: <<ArgValue:i\d+>> ParameterValue
113 /// CHECK: <<Const2:i\d+>> IntConstant 2
114 /// CHECK: <<Const30:i\d+>> IntConstant 30
115 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<Const2>>]
116 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Const30>>]
117 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
118 /// CHECK: Return [<<Or>>]
119
120 /// CHECK-START: int Main.ror_int_constant_c_c(int) instruction_simplifier (after)
121 /// CHECK: <<ArgValue:i\d+>> ParameterValue
122 /// CHECK: <<Const2:i\d+>> IntConstant 2
123 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Const2>>]
124 /// CHECK: Return [<<Ror>>]
125
126 /// CHECK-START: int Main.ror_int_constant_c_c(int) instruction_simplifier (after)
127 /// CHECK-NOT: UShr
128 /// CHECK-NOT: Shl
129 public static int ror_int_constant_c_c(int value) {
130 return (value >>> 2) | (value << 30);
131 }
132
133 /// CHECK-START: int Main.ror_int_constant_c_c_0(int) instruction_simplifier (after)
134 /// CHECK: <<ArgValue:i\d+>> ParameterValue
135 /// CHECK: <<Const2:i\d+>> IntConstant 2
136 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Const2>>]
137 /// CHECK: Return [<<Ror>>]
138
139 /// CHECK-START: int Main.ror_int_constant_c_c_0(int) instruction_simplifier (after)
140 /// CHECK-NOT: UShr
141 /// CHECK-NOT: Shl
142 public static int ror_int_constant_c_c_0(int value) {
143 return (value >>> 2) | (value << 62);
144 }
145
146 // (j >>> #distance) | (j << #(reg_bits - distance))
147
148 /// CHECK-START: long Main.ror_long_constant_c_c(long) instruction_simplifier (before)
149 /// CHECK: <<ArgValue:j\d+>> ParameterValue
150 /// CHECK: <<Const2:i\d+>> IntConstant 2
151 /// CHECK: <<Const62:i\d+>> IntConstant 62
152 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Const2>>]
153 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<Const62>>]
154 /// CHECK: <<Or:j\d+>> Or [<<UShr>>,<<Shl>>]
155 /// CHECK: Return [<<Or>>]
156
157 /// CHECK-START: long Main.ror_long_constant_c_c(long) instruction_simplifier (after)
158 /// CHECK: <<ArgValue:j\d+>> ParameterValue
159 /// CHECK: <<Const2:i\d+>> IntConstant 2
160 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Const2>>]
161 /// CHECK: Return [<<Ror>>]
162
163 /// CHECK-START: long Main.ror_long_constant_c_c(long) instruction_simplifier (after)
164 /// CHECK-NOT: UShr
165 /// CHECK-NOT: Shl
166 public static long ror_long_constant_c_c(long value) {
167 return (value >>> 2) | (value << 62);
168 }
169
170 /// CHECK-START: long Main.ror_long_constant_c_c_0(long) instruction_simplifier (after)
171 /// CHECK-NOT: Ror
172 public static long ror_long_constant_c_c_0(long value) {
173 return (value >>> 2) | (value << 30);
174 }
175
176 // (i >>> #distance) | (i << #-distance)
177
178 /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier (before)
179 /// CHECK: <<ArgValue:i\d+>> ParameterValue
180 /// CHECK: <<Const2:i\d+>> IntConstant 2
David Brazdil22c1f542016-04-25 17:47:43 +0100[diff] [blame]181 /// CHECK: <<ConstNeg2:i\d+>> IntConstant {{-2|30}}
Scott Wakeling40a04bf2015-12-11 09:50:36 +0000[diff] [blame]182 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<Const2>>]
183 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<ConstNeg2>>]
184 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
185 /// CHECK: Return [<<Or>>]
186
187 /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier (after)
188 /// CHECK: <<ArgValue:i\d+>> ParameterValue
189 /// CHECK: <<Const2:i\d+>> IntConstant 2
190 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Const2>>]
191 /// CHECK: Return [<<Ror>>]
192
193 /// CHECK-START: int Main.ror_int_constant_c_negc(int) instruction_simplifier (after)
194 /// CHECK-NOT: UShr
195 /// CHECK-NOT: Shl
196 public static int ror_int_constant_c_negc(int value) {
197 return (value >>> 2) | (value << -2);
198 }
199
200 // (j >>> #distance) | (j << #-distance)
201
202 /// CHECK-START: long Main.ror_long_constant_c_negc(long) instruction_simplifier (before)
203 /// CHECK: <<ArgValue:j\d+>> ParameterValue
204 /// CHECK: <<Const2:i\d+>> IntConstant 2
205 /// CHECK: <<ConstNeg2:i\d+>> IntConstant -2
206 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Const2>>]
207 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<ConstNeg2>>]
208 /// CHECK: <<Or:j\d+>> Or [<<UShr>>,<<Shl>>]
209 /// CHECK: Return [<<Or>>]
210
211 /// CHECK-START: long Main.ror_long_constant_c_negc(long) instruction_simplifier (after)
212 /// CHECK: <<ArgValue:j\d+>> ParameterValue
213 /// CHECK: <<Const2:i\d+>> IntConstant 2
214 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Const2>>]
215 /// CHECK: Return [<<Ror>>]
216
217 /// CHECK-START: long Main.ror_long_constant_c_negc(long) instruction_simplifier (after)
218 /// CHECK-NOT: UShr
219 /// CHECK-NOT: Shl
220 public static long ror_long_constant_c_negc(long value) {
221 return (value >>> 2) | (value << -2);
222 }
223
224 // (i >>> distance) | (i << (#reg_bits - distance)
225
226 /// CHECK-START: int Main.ror_int_reg_v_csubv(int, int) instruction_simplifier (before)
227 /// CHECK: <<ArgValue:i\d+>> ParameterValue
228 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
229 /// CHECK: <<Const32:i\d+>> IntConstant 32
230 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<ArgDistance>>]
231 /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const32>>,<<ArgDistance>>]
232 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Sub>>]
233 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
234 /// CHECK: Return [<<Or>>]
235
236 /// CHECK-START: int Main.ror_int_reg_v_csubv(int, int) instruction_simplifier (after)
237 /// CHECK: <<ArgValue:i\d+>> ParameterValue
238 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
239 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
240 /// CHECK: Return [<<Ror>>]
241
242 /// CHECK-START: int Main.ror_int_reg_v_csubv(int, int) instruction_simplifier (after)
243 /// CHECK-NOT: UShr
244 /// CHECK-NOT: Shl
245 /// CHECK-NOT: Sub
246 public static int ror_int_reg_v_csubv(int value, int distance) {
247 return (value >>> distance) | (value << (32 - distance));
248 }
249
250 // (distance = x - y)
251 // (i >>> distance) | (i << (#reg_bits - distance)
252
253 /// CHECK-START: int Main.ror_int_subv_csubv(int, int, int) instruction_simplifier (before)
254 /// CHECK: <<ArgValue:i\d+>> ParameterValue
255 /// CHECK: <<ArgX:i\d+>> ParameterValue
256 /// CHECK: <<ArgY:i\d+>> ParameterValue
257 /// CHECK: <<Const32:i\d+>> IntConstant 32
258 /// CHECK-DAG: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
259 /// CHECK-DAG: <<Sub32:i\d+>> Sub [<<Const32>>,<<SubDistance>>]
260 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Sub32>>]
261 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<SubDistance>>]
262 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
263 /// CHECK: Return [<<Or>>]
264
265 /// CHECK-START: int Main.ror_int_subv_csubv(int, int, int) instruction_simplifier (after)
266 /// CHECK: <<ArgValue:i\d+>> ParameterValue
267 /// CHECK: <<ArgX:i\d+>> ParameterValue
268 /// CHECK: <<ArgY:i\d+>> ParameterValue
269 /// CHECK: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
270 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<SubDistance>>]
271 /// CHECK: Return [<<Ror>>]
272
273 /// CHECK-START: int Main.ror_int_subv_csubv(int, int, int) instruction_simplifier (after)
274 /// CHECK: Sub
275 /// CHECK-NOT: Sub
276
277 /// CHECK-START: int Main.ror_int_subv_csubv(int, int, int) instruction_simplifier (after)
278 /// CHECK-NOT: UShr
279 /// CHECK-NOT: Shl
280 public static int ror_int_subv_csubv(int value, int x, int y) {
281 int distance = x - y;
282 return (value >>> distance) | (value << (32 - distance));
283 }
284
285 /// CHECK-START: int Main.ror_int_subv_csubv_env(int, int, int) instruction_simplifier (before)
286 /// CHECK: <<ArgValue:i\d+>> ParameterValue
287 /// CHECK: <<ArgX:i\d+>> ParameterValue
288 /// CHECK: <<ArgY:i\d+>> ParameterValue
289 /// CHECK: <<Const32:i\d+>> IntConstant 32
290 /// CHECK-DAG: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
291 /// CHECK-DAG: <<Sub32:i\d+>> Sub [<<Const32>>,<<SubDistance>>]
292 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<SubDistance>>]
293 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Sub32>>]
294 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
295 /// CHECK: <<Add:i\d+>> Add [<<Or>>,<<Sub32>>]
296 /// CHECK: Return [<<Add>>]
297
298 /// CHECK-START: int Main.ror_int_subv_csubv_env(int, int, int) instruction_simplifier (after)
299 /// CHECK: <<ArgValue:i\d+>> ParameterValue
300 /// CHECK: <<ArgX:i\d+>> ParameterValue
301 /// CHECK: <<ArgY:i\d+>> ParameterValue
302 /// CHECK: <<Const32:i\d+>> IntConstant 32
303 /// CHECK-DAG: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
304 /// CHECK-DAG: <<Sub32:i\d+>> Sub [<<Const32>>,<<SubDistance>>]
305 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<SubDistance>>]
306 /// CHECK: <<Add:i\d+>> Add [<<Ror>>,<<Sub32>>]
307 /// CHECK: Return [<<Add>>]
308
309 /// CHECK-START: int Main.ror_int_subv_csubv_env(int, int, int) instruction_simplifier (after)
310 /// CHECK-NOT: UShr
311 /// CHECK-NOT: Shl
312 public static int ror_int_subv_csubv_env(int value, int x, int y) {
313 int distance = x - y;
314 int bits_minus_dist = 32 - distance;
315 return ((value >>> distance) | (value << bits_minus_dist)) + bits_minus_dist;
316 }
317
318 // (j >>> distance) | (j << (#reg_bits - distance)
319
320 /// CHECK-START: long Main.ror_long_reg_v_csubv(long, int) instruction_simplifier (before)
321 /// CHECK: <<ArgValue:j\d+>> ParameterValue
322 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
323 /// CHECK: <<Const64:i\d+>> IntConstant 64
324 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<ArgDistance>>]
325 /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const64>>,<<ArgDistance>>]
326 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<Sub>>]
327 /// CHECK: <<Or:j\d+>> Or [<<UShr>>,<<Shl>>]
328 /// CHECK: Return [<<Or>>]
329
330 /// CHECK-START: long Main.ror_long_reg_v_csubv(long, int) instruction_simplifier (after)
331 /// CHECK: <<ArgValue:j\d+>> ParameterValue
332 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
333 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
334 /// CHECK: Return [<<Ror>>]
335
336 /// CHECK-START: long Main.ror_long_reg_v_csubv(long, int) instruction_simplifier (after)
337 /// CHECK-NOT: UShr
338 /// CHECK-NOT: Shl
339 /// CHECK-NOT: Sub
340 public static long ror_long_reg_v_csubv(long value, int distance) {
341 return (value >>> distance) | (value << (64 - distance));
342 }
343
344 /// CHECK-START: long Main.ror_long_reg_v_csubv_0(long, int) instruction_simplifier (after)
345 /// CHECK-NOT: Ror
346 public static long ror_long_reg_v_csubv_0(long value, int distance) {
347 return (value >>> distance) | (value << (32 - distance));
348 }
349
350 /// CHECK-START: long Main.ror_long_subv_csubv_0(long, int, int) instruction_simplifier (after)
351 /// CHECK-NOT: Ror
352 public static long ror_long_subv_csubv_0(long value, int x, int y) {
353 int distance = x - y;
354 return (value >>> distance) | (value << (32 - distance));
355 }
356
357 // (i >>> (#reg_bits - distance)) | (i << distance)
358
359 /// CHECK-START: int Main.rol_int_reg_csubv_v(int, int) instruction_simplifier (before)
360 /// CHECK: <<ArgValue:i\d+>> ParameterValue
361 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
362 /// CHECK: <<Const32:i\d+>> IntConstant 32
363 /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const32>>,<<ArgDistance>>]
364 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<Sub>>]
365 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
366 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
367 /// CHECK: Return [<<Or>>]
368
369 /// CHECK-START: int Main.rol_int_reg_csubv_v(int, int) instruction_simplifier (after)
370 /// CHECK: <<ArgValue:i\d+>> ParameterValue
371 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
372 /// CHECK: <<Const32:i\d+>> IntConstant 32
373 /// CHECK: <<Sub:i\d+>> Sub [<<Const32>>,<<ArgDistance>>]
374 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Sub>>]
375 /// CHECK: Return [<<Ror>>]
376
377 /// CHECK-START: int Main.rol_int_reg_csubv_v(int, int) instruction_simplifier (after)
378 /// CHECK-NOT: UShr
379 /// CHECK-NOT: Shl
380 public static int rol_int_reg_csubv_v(int value, int distance) {
381 return (value >>> (32 - distance)) | (value << distance);
382 }
383
384 // (distance = x - y)
385 // (i >>> (#reg_bits - distance)) | (i << distance)
386
387 /// CHECK-START: int Main.rol_int_csubv_subv(int, int, int) instruction_simplifier (before)
388 /// CHECK: <<ArgValue:i\d+>> ParameterValue
389 /// CHECK: <<ArgX:i\d+>> ParameterValue
390 /// CHECK: <<ArgY:i\d+>> ParameterValue
391 /// CHECK: <<Const32:i\d+>> IntConstant 32
392 /// CHECK-DAG: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
393 /// CHECK-DAG: <<Sub32:i\d+>> Sub [<<Const32>>,<<SubDistance>>]
394 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<SubDistance>>]
395 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<Sub32>>]
396 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
397 /// CHECK: Return [<<Or>>]
398
399 /// CHECK-START: int Main.rol_int_csubv_subv(int, int, int) instruction_simplifier (after)
400 /// CHECK: <<ArgValue:i\d+>> ParameterValue
401 /// CHECK: <<ArgX:i\d+>> ParameterValue
402 /// CHECK: <<ArgY:i\d+>> ParameterValue
403 /// CHECK: <<Const32:i\d+>> IntConstant 32
404 /// CHECK: <<SubDistance:i\d+>> Sub [<<ArgX>>,<<ArgY>>]
405 /// CHECK: <<Sub:i\d+>> Sub [<<Const32>>,<<SubDistance>>]
406 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Sub>>]
407 /// CHECK: Return [<<Ror>>]
408
409 /// CHECK-START: int Main.rol_int_csubv_subv(int, int, int) instruction_simplifier (after)
410 /// CHECK: Sub
411 /// CHECK: Sub
412
413 /// CHECK-START: int Main.rol_int_csubv_subv(int, int, int) instruction_simplifier (after)
414 /// CHECK-NOT: UShr
415 /// CHECK-NOT: Shl
416 public static int rol_int_csubv_subv(int value, int x, int y) {
417 int distance = x - y;
418 return (value >>> (32 - distance)) | (value << distance);
419 }
420
421 // (j >>> (#reg_bits - distance)) | (j << distance)
422
423 /// CHECK-START: long Main.rol_long_reg_csubv_v(long, int) instruction_simplifier (before)
424 /// CHECK: <<ArgValue:j\d+>> ParameterValue
425 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
426 /// CHECK: <<Const64:i\d+>> IntConstant 64
427 /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const64>>,<<ArgDistance>>]
428 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Sub>>]
429 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
430 /// CHECK: <<Or:j\d+>> Or [<<UShr>>,<<Shl>>]
431 /// CHECK: Return [<<Or>>]
432
433 /// CHECK-START: long Main.rol_long_reg_csubv_v(long, int) instruction_simplifier (after)
434 /// CHECK: <<ArgValue:j\d+>> ParameterValue
435 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
436 /// CHECK: <<Const64:i\d+>> IntConstant 64
437 /// CHECK: <<Sub:i\d+>> Sub [<<Const64>>,<<ArgDistance>>]
438 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Sub>>]
439 /// CHECK: Return [<<Ror>>]
440
441 /// CHECK-START: long Main.rol_long_reg_csubv_v(long, int) instruction_simplifier (after)
442 /// CHECK-NOT: UShr
443 /// CHECK-NOT: Shl
444 public static long rol_long_reg_csubv_v(long value, int distance) {
445 return (value >>> (64 - distance)) | (value << distance);
446 }
447
448 /// CHECK-START: long Main.rol_long_reg_csubv_v_0(long, int) instruction_simplifier (after)
449 /// CHECK-NOT: Ror
450 public static long rol_long_reg_csubv_v_0(long value, int distance) {
451 return (value >>> (32 - distance)) | (value << distance);
452 }
453
454 // (i >>> distance) | (i << -distance) (i.e. libcore's Integer.rotateRight)
455
456 /// CHECK-START: int Main.ror_int_reg_v_negv(int, int) instruction_simplifier (before)
457 /// CHECK: <<ArgValue:i\d+>> ParameterValue
458 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
459 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<ArgDistance>>]
460 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
461 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Neg>>]
462 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
463 /// CHECK: Return [<<Or>>]
464
465 /// CHECK-START: int Main.ror_int_reg_v_negv(int, int) instruction_simplifier (after)
466 /// CHECK: <<ArgValue:i\d+>> ParameterValue
467 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
468 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
469 /// CHECK: Return [<<Ror>>]
470
471 /// CHECK-START: int Main.ror_int_reg_v_negv(int, int) instruction_simplifier (after)
472 /// CHECK-NOT: UShr
473 /// CHECK-NOT: Shl
474 /// CHECK-NOT: Neg
475 public static int ror_int_reg_v_negv(int value, int distance) {
476 return (value >>> distance) | (value << -distance);
477 }
478
479 /// CHECK-START: int Main.ror_int_reg_v_negv_env(int, int) instruction_simplifier (before)
480 /// CHECK: <<ArgValue:i\d+>> ParameterValue
481 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
482 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
483 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<ArgDistance>>]
484 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<Neg>>]
485 /// CHECK: <<Or:i\d+>> Or [<<UShr>>,<<Shl>>]
486 /// CHECK: <<Add:i\d+>> Add [<<Or>>,<<Neg>>]
487 /// CHECK: Return [<<Add>>]
488
489 /// CHECK-START: int Main.ror_int_reg_v_negv_env(int, int) instruction_simplifier (after)
490 /// CHECK: <<ArgValue:i\d+>> ParameterValue
491 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
492 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
493 /// CHECK: <<Sub:i\d+>> Sub [<<Ror>>,<<ArgDistance>>]
494 /// CHECK: Return [<<Sub>>]
495
496 /// CHECK-START: int Main.ror_int_reg_v_negv_env(int, int) instruction_simplifier (after)
497 /// CHECK-NOT: UShr
498 /// CHECK-NOT: Shl
499 public static int ror_int_reg_v_negv_env(int value, int distance) {
500 int neg_distance = -distance;
501 return ((value >>> distance) | (value << neg_distance)) + neg_distance;
502 }
503
504 // (j >>> distance) | (j << -distance) (i.e. libcore's Long.rotateRight)
505
506 /// CHECK-START: long Main.ror_long_reg_v_negv(long, int) instruction_simplifier (before)
507 /// CHECK: <<ArgValue:j\d+>> ParameterValue
508 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
509 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<ArgDistance>>]
510 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
511 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<Neg>>]
512 /// CHECK: <<Or:j\d+>> Or [<<UShr>>,<<Shl>>]
513 /// CHECK: Return [<<Or>>]
514
515 /// CHECK-START: long Main.ror_long_reg_v_negv(long, int) instruction_simplifier (after)
516 /// CHECK: <<ArgValue:j\d+>> ParameterValue
517 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
518 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
519 /// CHECK: Return [<<Ror>>]
520
521 /// CHECK-START: long Main.ror_long_reg_v_negv(long, int) instruction_simplifier (after)
522 /// CHECK-NOT: UShr
523 /// CHECK-NOT: Shl
524 /// CHECK-NOT: Neg
525 public static long ror_long_reg_v_negv(long value, int distance) {
526 return (value >>> distance) | (value << -distance);
527 }
528
529 // (i << distance) | (i >>> -distance) (i.e. libcore's Integer.rotateLeft)
530
531 /// CHECK-START: int Main.rol_int_reg_negv_v(int, int) instruction_simplifier (before)
532 /// CHECK: <<ArgValue:i\d+>> ParameterValue
533 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
534 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
535 /// CHECK-DAG: <<UShr:i\d+>> UShr [<<ArgValue>>,<<Neg>>]
536 /// CHECK-DAG: <<Shl:i\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
537 /// CHECK: <<Or:i\d+>> Or [<<Shl>>,<<UShr>>]
538 /// CHECK: Return [<<Or>>]
539
540 /// CHECK-START: int Main.rol_int_reg_negv_v(int, int) instruction_simplifier (after)
541 /// CHECK: <<ArgValue:i\d+>> ParameterValue
542 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
543 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
544 /// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Neg>>]
545 /// CHECK: Return [<<Ror>>]
546
547 /// CHECK-START: int Main.rol_int_reg_negv_v(int, int) instruction_simplifier (after)
548 /// CHECK-NOT: UShr
549 /// CHECK-NOT: Shl
550 public static int rol_int_reg_negv_v(int value, int distance) {
551 return (value << distance) | (value >>> -distance);
552 }
553
554 // (j << distance) | (j >>> -distance) (i.e. libcore's Long.rotateLeft)
555
556 /// CHECK-START: long Main.rol_long_reg_negv_v(long, int) instruction_simplifier (before)
557 /// CHECK: <<ArgValue:j\d+>> ParameterValue
558 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
559 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
560 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Neg>>]
561 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
562 /// CHECK: <<Or:j\d+>> Or [<<Shl>>,<<UShr>>]
563 /// CHECK: Return [<<Or>>]
564
565 /// CHECK-START: long Main.rol_long_reg_negv_v(long, int) instruction_simplifier (after)
566 /// CHECK: <<ArgValue:j\d+>> ParameterValue
567 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
568 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
569 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
570 /// CHECK: Return [<<Ror>>]
571
572 /// CHECK-START: long Main.rol_long_reg_negv_v(long, int) instruction_simplifier (after)
573 /// CHECK-NOT: UShr
574 /// CHECK-NOT: Shl
575 public static long rol_long_reg_negv_v(long value, int distance) {
576 return (value << distance) | (value >>> -distance);
577 }
578
579 // (j << distance) + (j >>> -distance)
580
581 /// CHECK-START: long Main.rol_long_reg_v_negv_add(long, int) instruction_simplifier (before)
582 /// CHECK: <<ArgValue:j\d+>> ParameterValue
583 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
584 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
585 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Neg>>]
586 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
587 /// CHECK: <<Add:j\d+>> Add [<<Shl>>,<<UShr>>]
588 /// CHECK: Return [<<Add>>]
589
590 /// CHECK-START: long Main.rol_long_reg_v_negv_add(long, int) instruction_simplifier (after)
591 /// CHECK: <<ArgValue:j\d+>> ParameterValue
592 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
593 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
594 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
595 /// CHECK: Return [<<Ror>>]
596
597 /// CHECK-START: long Main.rol_long_reg_v_negv_add(long, int) instruction_simplifier (after)
598 /// CHECK-NOT: Add
599 /// CHECK-NOT: Shl
600 /// CHECK-NOT: UShr
601 public static long rol_long_reg_v_negv_add(long value, int distance) {
602 return (value << distance) + (value >>> -distance);
603 }
604
605 // (j << distance) ^ (j >>> -distance)
606
607 /// CHECK-START: long Main.rol_long_reg_v_negv_xor(long, int) instruction_simplifier (before)
608 /// CHECK: <<ArgValue:j\d+>> ParameterValue
609 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
610 /// CHECK-DAG: <<Neg:i\d+>> Neg [<<ArgDistance>>]
611 /// CHECK-DAG: <<UShr:j\d+>> UShr [<<ArgValue>>,<<Neg>>]
612 /// CHECK-DAG: <<Shl:j\d+>> Shl [<<ArgValue>>,<<ArgDistance>>]
613 /// CHECK: <<Xor:j\d+>> Xor [<<Shl>>,<<UShr>>]
614 /// CHECK: Return [<<Xor>>]
615
616 /// CHECK-START: long Main.rol_long_reg_v_negv_xor(long, int) instruction_simplifier (after)
617 /// CHECK: <<ArgValue:j\d+>> ParameterValue
618 /// CHECK: <<ArgDistance:i\d+>> ParameterValue
619 /// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
620 /// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
621 /// CHECK: Return [<<Ror>>]
622
623 /// CHECK-START: long Main.rol_long_reg_v_negv_xor(long, int) instruction_simplifier (after)
624 /// CHECK-NOT: Xor
625 /// CHECK-NOT: Shl
626 /// CHECK-NOT: UShr
627 public static long rol_long_reg_v_negv_xor(long value, int distance) {
628 return (value << distance) ^ (value >>> -distance);
629 }
630
631 public static void main(String[] args) {
632 assertIntEquals(2, ror_int_constant_c_c(8));
633 assertIntEquals(2, ror_int_constant_c_c_0(8));
634 assertLongEquals(2L, ror_long_constant_c_c(8L));
635
636 assertIntEquals(2, ror_int_constant_c_negc(8));
637 assertLongEquals(2L, ror_long_constant_c_negc(8L));
638
639 assertIntEquals(2, ror_int_reg_v_csubv(8, 2));
640 assertLongEquals(2L, ror_long_reg_v_csubv(8L, 2));
641
642 assertIntEquals(2, ror_int_subv_csubv(8, 2, 0));
643 assertIntEquals(32, ror_int_subv_csubv_env(8, 2, 0));
644 assertIntEquals(32, rol_int_csubv_subv(8, 2, 0));
645
646 assertIntEquals(32, rol_int_reg_csubv_v(8, 2));
647 assertLongEquals(32L, rol_long_reg_csubv_v(8L, 2));
648
649 assertIntEquals(2, ror_int_reg_v_negv(8, 2));
650 assertIntEquals(0, ror_int_reg_v_negv_env(8, 2));
651 assertLongEquals(2L, ror_long_reg_v_negv(8L, 2));
652
653 assertIntEquals(32, rol_int_reg_negv_v(8, 2));
654 assertLongEquals(32L, rol_long_reg_negv_v(8L, 2));
655
656 assertLongEquals(32L, rol_long_reg_v_negv_add(8L, 2));
657 assertLongEquals(32L, rol_long_reg_v_negv_xor(8L, 2));
658 }
659}