• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
17 /**
18  * Regression tests for loop optimizations.
19  */
20 public class Main {
21 
ensureJitCompiled(Class<?> cls, String methodName)22   private static native void ensureJitCompiled(Class<?> cls, String methodName);
23 
24   /// CHECK-START: int Main.earlyExitFirst(int) loop_optimization (before)
25   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
26   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
27   //
28   /// CHECK-START: int Main.earlyExitFirst(int) loop_optimization (after)
29   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
30   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
earlyExitFirst(int m)31   static int earlyExitFirst(int m) {
32     int k = 0;
33     for (int i = 0; i < 10; i++) {
34       if (i == m) {
35         return k;
36       }
37       k++;
38     }
39     return k;
40   }
41 
42   /// CHECK-START: int Main.earlyExitLast(int) loop_optimization (before)
43   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
44   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
45   //
46   /// CHECK-START: int Main.earlyExitLast(int) loop_optimization (after)
47   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
48   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
earlyExitLast(int m)49   static int earlyExitLast(int m) {
50     int k = 0;
51     for (int i = 0; i < 10; i++) {
52       k++;
53       if (i == m) {
54         return k;
55       }
56     }
57     return k;
58   }
59 
60   /// CHECK-START: int Main.earlyExitNested() loop_optimization (before)
61   /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
62   /// CHECK-DAG: Phi loop:<<Loop1>>      outer_loop:none
63   /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:<<Loop1>>
64   /// CHECK-DAG: Phi loop:<<Loop2>>      outer_loop:<<Loop1>>
65   //
66   /// CHECK-START: int Main.earlyExitNested() loop_optimization (after)
67   /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
68   /// CHECK-DAG: Phi loop:<<Loop1>>      outer_loop:none
69   //
70   /// CHECK-START: int Main.earlyExitNested() loop_optimization (after)
71   /// CHECK-NOT: Phi loop:{{B\d+}} outer_loop:{{B\d+}}
earlyExitNested()72   static int earlyExitNested() {
73     int offset = 0;
74     for (int i = 0; i < 2; i++) {
75       int start = offset;
76       // This loop can be removed.
77       for (int j = 0; j < 2; j++) {
78         offset++;
79       }
80       if (i == 1) {
81         return start;
82       }
83     }
84     return 0;
85   }
86 
87   // Regression test for b/33774618: transfer operations involving
88   // narrowing linear induction should be done correctly.
89   //
90   /// CHECK-START: int Main.transferNarrowWrap() loop_optimization (before)
91   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
92   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
93   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
94   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
95   //
96   /// CHECK-START: int Main.transferNarrowWrap() loop_optimization (after)
97   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
98   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
99   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
100   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
transferNarrowWrap()101   static int transferNarrowWrap() {
102     short x = 0;
103     int w = 10;
104     int v = 3;
105     for (int i = 0; i < 10; i++) {
106       v = w + 1;    // transfer on wrap-around
107       w = x;   // wrap-around
108       x += 2;  // narrowing linear
109     }
110     return v;
111   }
112 
113   // Regression test for b/33774618: transfer operations involving
114   // narrowing linear induction should be done correctly
115   // (currently rejected, could be improved).
116   //
117   /// CHECK-START: int Main.polynomialShort() loop_optimization (before)
118   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
119   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
120   //
121   /// CHECK-START: int Main.polynomialShort() loop_optimization (after)
122   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
123   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
polynomialShort()124   static int polynomialShort() {
125     int x = 0;
126     for (short i = 0; i < 10; i++) {
127       x = x - i;  // polynomial on narrowing linear
128     }
129     return x;
130   }
131 
132   // Regression test for b/33774618: transfer operations involving
133   // narrowing linear induction should be done correctly
134   // (currently rejected, could be improved).
135   //
136   /// CHECK-START: int Main.polynomialIntFromLong() loop_optimization (before)
137   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
138   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
139   //
140   /// CHECK-START: int Main.polynomialIntFromLong() loop_optimization (after)
141   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
142   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
polynomialIntFromLong()143   static int polynomialIntFromLong() {
144     int x = 0;
145     for (long i = 0; i < 10; i++) {
146       x = x - (int) i;  // polynomial on narrowing linear
147     }
148     return x;
149   }
150 
151   /// CHECK-START: int Main.polynomialInt() loop_optimization (before)
152   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
153   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
154   //
155   /// CHECK-START: int Main.polynomialInt() loop_optimization (after)
156   /// CHECK-NOT: Phi
157   //
158   /// CHECK-START: int Main.polynomialInt() instruction_simplifier$before_codegen (after)
159   /// CHECK-DAG: <<Int:i\d+>>  IntConstant -45  loop:none
160   /// CHECK-DAG:               Return [<<Int>>] loop:none
polynomialInt()161   static int polynomialInt() {
162     int x = 0;
163     for (int i = 0; i < 10; i++) {
164       x = x - i;
165     }
166     return x;
167   }
168 
169   // Regression test for b/34779592 (found with fuzz testing): overflow for last value
170   // of division truncates to zero, for multiplication it simply truncates.
171   //
172   /// CHECK-START: int Main.geoIntDivLastValue(int) loop_optimization (before)
173   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
174   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
175   //
176   /// CHECK-START: int Main.geoIntDivLastValue(int) loop_optimization (after)
177   /// CHECK-NOT: Phi
178   //
179   /// CHECK-START: int Main.geoIntDivLastValue(int) instruction_simplifier$before_codegen (after)
180   /// CHECK-DAG: <<Int:i\d+>> IntConstant 0    loop:none
181   /// CHECK-DAG:              Return [<<Int>>] loop:none
geoIntDivLastValue(int x)182   static int geoIntDivLastValue(int x) {
183     for (int i = 0; i < 2; i++) {
184       x /= 1081788608;
185     }
186     return x;
187   }
188 
189   /// CHECK-START: int Main.geoIntMulLastValue(int) loop_optimization (before)
190   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
191   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
192   //
193   /// CHECK-START: int Main.geoIntMulLastValue(int) loop_optimization (after)
194   /// CHECK-NOT: Phi
195   //
196   /// CHECK-START: int Main.geoIntMulLastValue(int) instruction_simplifier$before_codegen (after)
197   /// CHECK-DAG: <<Par:i\d+>> ParameterValue         loop:none
198   /// CHECK-DAG: <<Int:i\d+>> IntConstant -194211840 loop:none
199   /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Par>>,<<Int>>]  loop:none
200   /// CHECK-DAG:              Return [<<Mul>>]       loop:none
geoIntMulLastValue(int x)201   static int geoIntMulLastValue(int x) {
202     for (int i = 0; i < 2; i++) {
203       x *= 1081788608;
204     }
205     return x;
206   }
207 
208   /// CHECK-START: long Main.geoLongDivLastValue(long) loop_optimization (before)
209   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
210   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
211   //
212   /// CHECK-START: long Main.geoLongDivLastValue(long) loop_optimization (after)
213   /// CHECK-NOT: Phi
214   //
215   /// CHECK-START: long Main.geoLongDivLastValue(long) instruction_simplifier$before_codegen (after)
216   /// CHECK-DAG: <<Long:j\d+>> LongConstant 0    loop:none
217   /// CHECK-DAG:               Return [<<Long>>] loop:none
218   //
219   // Tests overflow in the divisor (while updating intermediate result).
geoLongDivLastValue(long x)220   static long geoLongDivLastValue(long x) {
221     for (int i = 0; i < 10; i++) {
222       x /= 1081788608;
223     }
224     return x;
225   }
226 
227   /// CHECK-START: long Main.geoLongDivLastValue() loop_optimization (before)
228   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
229   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
230   //
231   /// CHECK-START: long Main.geoLongDivLastValue() loop_optimization (after)
232   /// CHECK-NOT: Phi
233   //
234   /// CHECK-START: long Main.geoLongDivLastValue() instruction_simplifier$before_codegen (after)
235   /// CHECK-DAG: <<Long:j\d+>> LongConstant 0    loop:none
236   /// CHECK-DAG:               Return [<<Long>>] loop:none
237   //
238   // Tests overflow in the divisor (while updating base).
geoLongDivLastValue()239   static long geoLongDivLastValue() {
240     long x = -1;
241     for (int i2 = 0; i2 < 2; i2++) {
242       x /= (Long.MAX_VALUE);
243     }
244     return x;
245   }
246 
247   /// CHECK-START: long Main.geoLongMulLastValue(long) loop_optimization (before)
248   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
249   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
250   //
251   /// CHECK-START: long Main.geoLongMulLastValue(long) loop_optimization (after)
252   /// CHECK-NOT: Phi
253   //
254   /// CHECK-START: long Main.geoLongMulLastValue(long) instruction_simplifier$before_codegen (after)
255   /// CHECK-DAG: <<Par:j\d+>>  ParameterValue                    loop:none
256   /// CHECK-DAG: <<Long:j\d+>> LongConstant -8070450532247928832 loop:none
257   /// CHECK-DAG: <<Mul:j\d+>>  Mul [<<Par>>,<<Long>>]            loop:none
258   /// CHECK-DAG:               Return [<<Mul>>]                  loop:none
geoLongMulLastValue(long x)259   static long geoLongMulLastValue(long x) {
260     for (int i = 0; i < 10; i++) {
261       x *= 1081788608;
262     }
263     return x;
264   }
265 
266   // If vectorized, the narrowing subscript should not cause
267   // type inconsistencies in the synthesized code.
narrowingSubscript(float[] a)268   static void narrowingSubscript(float[] a) {
269     float val = 2.0f;
270     for (long i = 0; i < a.length; i++) {
271       a[(int) i] += val;
272     }
273   }
274 
275   // If vectorized, invariant stride should be recognized
276   // as a reduction, not a unit stride in outer loop.
reduc(int[] xx, int[] yy)277   static void reduc(int[] xx, int[] yy) {
278     for (int i0 = 0; i0 < 2; i0++) {
279       for (int i1 = 0; i1 < 469; i1++) {
280         xx[i0] -= (++yy[i1]);
281       }
282     }
283   }
284 
285   /// CHECK-START: void Main.string2Bytes(char[], java.lang.String) loop_optimization (before)
286   /// CHECK-DAG: ArrayGet loop:<<Loop:B\d+>> outer_loop:none
287   /// CHECK-DAG: ArraySet loop:<<Loop>>      outer_loop:none
288   //
289   /// CHECK-START-ARM: void Main.string2Bytes(char[], java.lang.String) loop_optimization (after)
290   /// CHECK-NOT: VecLoad
291   //
292   /// CHECK-START-ARM64: void Main.string2Bytes(char[], java.lang.String) loop_optimization (after)
293   /// CHECK-IF:     hasIsaFeature("sve")
294   //
295   //      TODO: Support CharAt for SVE.
296   ///     CHECK-NOT: VecLoad
297   //
298   /// CHECK-ELSE:
299   //
300   ///     CHECK-DAG: VecLoad  loop:<<Loop:B\d+>> outer_loop:none
301   ///     CHECK-DAG: VecStore loop:<<Loop>>      outer_loop:none
302   //
303   /// CHECK-FI:
304   //
305   // NOTE: should correctly deal with compressed and uncompressed cases.
string2Bytes(char[] a, String b)306   private static void string2Bytes(char[] a, String b) {
307     int min = Math.min(a.length, b.length());
308     for (int i = 0; i < min; i++) {
309       a[i] = b.charAt(i);
310     }
311   }
312 
313   /// CHECK-START-ARM: void Main.$noinline$stringToShorts(short[], java.lang.String) loop_optimization (after)
314   /// CHECK-NOT: VecLoad
315 
316   /// CHECK-START-ARM64: void Main.$noinline$stringToShorts(short[], java.lang.String) loop_optimization (after)
317   /// CHECK-IF:     hasIsaFeature("sve")
318   //
319   //      TODO: Support CharAt for SVE.
320   ///     CHECK-NOT: VecLoad
321   //
322   /// CHECK-ELSE:
323   //
324   ///     CHECK-DAG: VecLoad  loop:<<Loop:B\d+>> outer_loop:none
325   ///     CHECK-DAG: VecStore loop:<<Loop>>      outer_loop:none
326   //
327   /// CHECK-FI:
$noinline$stringToShorts(short[] dest, String src)328   private static void $noinline$stringToShorts(short[] dest, String src) {
329     int min = Math.min(dest.length, src.length());
330     for (int i = 0; i < min; ++i) {
331       dest[i] = (short) src.charAt(i);
332     }
333   }
334 
335   // A strange function that does not inline.
$noinline$foo(boolean x, int n)336   private static void $noinline$foo(boolean x, int n) {
337     if (n < 0)
338       throw new Error("oh no");
339     if (n > 100) {
340       $noinline$foo(!x, n - 1);
341       $noinline$foo(!x, n - 2);
342       $noinline$foo(!x, n - 3);
343       $noinline$foo(!x, n - 4);
344     }
345   }
346 
347   // A loop with environment uses of x (the terminating condition). As exposed by bug
348   // b/37247891, the loop can be unrolled, but should handle the (unlikely, but clearly
349   // not impossible) environment uses of the terminating condition in a correct manner.
envUsesInCond()350   private static void envUsesInCond() {
351     boolean x = false;
352     for (int i = 0; !(x = i >= 1); i++) {
353       $noinline$foo(true, i);
354     }
355   }
356 
357   /// CHECK-START: void Main.oneBoth(short[], char[]) loop_optimization (before)
358   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                       loop:none
359   /// CHECK-DAG: <<Phi:i\d+>>  Phi                                 loop:<<Loop:B\d+>> outer_loop:none
360   /// CHECK-DAG:               ArraySet [{{l\d+}},<<Phi>>,<<One>>] loop:<<Loop>>      outer_loop:none
361   /// CHECK-DAG:               ArraySet [{{l\d+}},<<Phi>>,<<One>>] loop:<<Loop>>      outer_loop:none
362   //
363   /// CHECK-START-ARM: void Main.oneBoth(short[], char[]) loop_optimization (after)
364   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                             loop:none
365   /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>]              loop:none
366   /// CHECK-DAG:               VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>] loop:<<Loop:B\d+>> outer_loop:none
367   /// CHECK-DAG:               VecStore [{{l\d+}},<<Phi>>,<<Repl>>]      loop:<<Loop>>      outer_loop:none
368   //
369   /// CHECK-START-ARM64: void Main.oneBoth(short[], char[]) loop_optimization (after)
370   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                             loop:none
371   /// CHECK-IF:     hasIsaFeature("sve")
372   //
373   ///     CHECK-DAG: <<Repl:d\d+>>  VecReplicateScalar [<<One>>,{{j\d+}}]               loop:none
374   ///     CHECK-DAG: <<LoopP:j\d+>> VecPredWhile                                        loop:<<Loop:B\d+>> outer_loop:none
375   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>,<<LoopP>>] loop:<<Loop>>      outer_loop:none
376   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi>>,<<Repl>>,<<LoopP>>]      loop:<<Loop>>      outer_loop:none
377   //
378   /// CHECK-ELSE:
379   //
380   ///     CHECK-DAG: <<Repl:d\d+>>  VecReplicateScalar [<<One>>]              loop:none
381   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi:i\d+>>,<<Repl>>] loop:<<Loop:B\d+>> outer_loop:none
382   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi>>,<<Repl>>]      loop:<<Loop>>      outer_loop:none
383   //
384   /// CHECK-FI:
385   //
386   // Bug b/37764324: integral same-length packed types can be mixed freely.
oneBoth(short[] a, char[] b)387   private static void oneBoth(short[] a, char[] b) {
388     for (int i = 0; i < Math.min(a.length, b.length); i++) {
389       a[i] = 1;
390       b[i] = 1;
391     }
392   }
393 
394   // Bug b/37768917: potential dynamic BCE vs. loop optimizations
395   // case should be deal with correctly (used to DCHECK fail).
arrayInTripCount(int[] a, byte[] b, int n)396   private static void arrayInTripCount(int[] a, byte[] b, int n) {
397     for (int k = 0; k < n; k++) {
398       for (int i = 0, u = a[0]; i < u; i++) {
399         b[i] += 2;
400       }
401     }
402   }
403 
404   /// CHECK-START: void Main.typeConv(byte[], byte[]) loop_optimization (before)
405   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                       loop:none
406   /// CHECK-DAG: <<Phi:i\d+>>  Phi                                 loop:<<Loop:B\d+>> outer_loop:none
407   /// CHECK-DAG: <<Get:b\d+>>  ArrayGet [{{l\d+}},<<Phi>>]         loop:<<Loop>>      outer_loop:none
408   /// CHECK-DAG: <<Add:i\d+>>  Add [<<Get>>,<<One>>]               loop:<<Loop>>      outer_loop:none
409   /// CHECK-DAG: <<Cnv:b\d+>>  TypeConversion [<<Add>>]            loop:<<Loop>>      outer_loop:none
410   /// CHECK-DAG:               ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>>      outer_loop:none
411   //
412   /// CHECK-START-ARM: void Main.typeConv(byte[], byte[]) loop_optimization (after)
413   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                         loop:none
414 
415   /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<One>>]          loop:none
416   /// CHECK-DAG: <<Load:d\d+>> VecLoad [{{l\d+}},<<Phi1:i\d+>>]      loop:<<Loop1:B\d+>> outer_loop:none
417   /// CHECK-DAG: <<Vadd:d\d+>> VecAdd [<<Load>>,<<Repl>>]            loop:<<Loop1>>      outer_loop:none
418   /// CHECK-DAG:               VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>] loop:<<Loop1>>      outer_loop:none
419   /// CHECK-DAG: <<Get:b\d+>>  ArrayGet [{{l\d+}},<<Phi2:i\d+>>]     loop:<<Loop2:B\d+>> outer_loop:none
420   /// CHECK-DAG: <<Add:i\d+>>  Add [<<Get>>,<<One>>]                 loop:<<Loop2>>      outer_loop:none
421   /// CHECK-DAG: <<Cnv:b\d+>>  TypeConversion [<<Add>>]              loop:<<Loop2>>      outer_loop:none
422   /// CHECK-DAG:               ArraySet [{{l\d+}},<<Phi2>>,<<Cnv>>]  loop:<<Loop2>>      outer_loop:none
423   //
424   /// CHECK-START-ARM64: void Main.typeConv(byte[], byte[]) loop_optimization (after)
425   /// CHECK-DAG: <<One:i\d+>>  IntConstant 1                         loop:none
426   /// CHECK-IF:     hasIsaFeature("sve")
427   //
428   ///     CHECK-DAG: <<Repl:d\d+>>  VecReplicateScalar [<<One>>,{{j\d+}}]           loop:none
429   ///     CHECK-DAG: <<LoopP:j\d+>> VecPredWhile                                    loop:<<Loop1:B\d+>> outer_loop:none
430   ///     CHECK-DAG: <<Load:d\d+>>  VecLoad [{{l\d+}},<<Phi1:i\d+>>,<<LoopP>>]      loop:<<Loop1>>      outer_loop:none
431   ///     CHECK-DAG: <<Vadd:d\d+>>  VecAdd [<<Load>>,<<Repl>>,<<LoopP>>]            loop:<<Loop1>>      outer_loop:none
432   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>,<<LoopP>>] loop:<<Loop1>>      outer_loop:none
433   //
434   /// CHECK-ELSE:
435   //
436   ///     CHECK-DAG: <<Repl:d\d+>>  VecReplicateScalar [<<One>>]          loop:none
437   ///     CHECK-DAG: <<Load:d\d+>>  VecLoad [{{l\d+}},<<Phi1:i\d+>>]      loop:<<Loop1:B\d+>> outer_loop:none
438   ///     CHECK-DAG: <<Vadd:d\d+>>  VecAdd [<<Load>>,<<Repl>>]            loop:<<Loop1>>      outer_loop:none
439   ///     CHECK-DAG:                VecStore [{{l\d+}},<<Phi1>>,<<Vadd>>] loop:<<Loop1>>      outer_loop:none
440   ///     CHECK-DAG: <<Get:b\d+>>   ArrayGet [{{l\d+}},<<Phi2:i\d+>>]     loop:<<Loop2:B\d+>> outer_loop:none
441   ///     CHECK-DAG: <<Add:i\d+>>   Add [<<Get>>,<<One>>]                 loop:<<Loop2>>      outer_loop:none
442   ///     CHECK-DAG: <<Cnv:b\d+>>   TypeConversion [<<Add>>]              loop:<<Loop2>>      outer_loop:none
443   ///     CHECK-DAG:                ArraySet [{{l\d+}},<<Phi2>>,<<Cnv>>]  loop:<<Loop2>>      outer_loop:none
444   //
445   /// CHECK-FI:
446   //
447   // Scalar code in cleanup loop uses correct byte type on array get and type conversion.
typeConv(byte[] a, byte[] b)448   private static void typeConv(byte[] a, byte[] b) {
449     int len = Math.min(a.length, b.length);
450     for (int i = 0; i < len; i++) {
451       a[i] = (byte) (b[i] + 1);
452     }
453   }
454 
455   // Environment of an instruction, removed during SimplifyInduction, should be adjusted.
456   //
457   /// CHECK-START: void Main.inductionMax(int[]) loop_optimization (before)
458   /// CHECK-DAG: Phi loop:<<Loop:B\d+>> outer_loop:none
459   /// CHECK-DAG: Phi loop:<<Loop>>      outer_loop:none
460   //
461   /// CHECK-START: void Main.inductionMax(int[]) loop_optimization (after)
462   /// CHECK-NOT: Phi
inductionMax(int[] a)463   private static void inductionMax(int[] a) {
464    int s = 0;
465     for (int i = 0; i < 10; i++) {
466       s = Math.max(s, 5);
467     }
468   }
469 
470   /// CHECK-START: int Main.feedsIntoDeopt(int[]) loop_optimization (before)
471   /// CHECK-DAG: Phi loop:<<Loop1:B\d+>> outer_loop:none
472   /// CHECK-DAG: Phi loop:<<Loop1>>      outer_loop:none
473   /// CHECK-DAG: Phi loop:<<Loop2:B\d+>> outer_loop:none
474   //
475   /// CHECK-EVAL: "<<Loop1>>" != "<<Loop2>>"
476   //
477   /// CHECK-START: int Main.feedsIntoDeopt(int[]) loop_optimization (after)
478   /// CHECK-DAG: Phi loop:{{B\d+}} outer_loop:none
479   /// CHECK-NOT: Phi
feedsIntoDeopt(int[] a)480   static int feedsIntoDeopt(int[] a) {
481     // Reduction should be removed.
482     int r = 0;
483     for (int i = 0; i < 100; i++) {
484       r += 10;
485     }
486     // Even though uses feed into deopts of BCE.
487     for (int i = 1; i < 100; i++) {
488       a[i] = a[i - 1];
489     }
490     return r;
491   }
492 
absCanBeNegative(int x)493   static int absCanBeNegative(int x) {
494     int a[] = { 1, 2, 3 };
495     int y = 0;
496     for (int i = Math.abs(x); i < a.length; i++) {
497       y += a[i];
498     }
499     return y;
500   }
501 
502   // b/65478356: sum up 2-dim array.
sum(int[][] a)503   static int sum(int[][] a) {
504     int sum = 0;
505     for (int y = 0; y < a.length; y++) {
506       int[] aa = a[y];
507       for (int x = 0; x < aa.length; x++) {
508         sum += aa[x];
509       }
510     }
511     return sum;
512   }
513 
514   // Large loop body should not break unrolling computation.
largeBody(int[] x)515   static void largeBody(int[] x) {
516     for (int i = 0; i < 100; i++) {
517       x[i] = x[i] * 1 + x[i] * 2 + x[i] * 3 + x[i] * 4 + x[i] * 5 + x[i] * 6 +
518           x[i] * 7 + x[i] * 8 + x[i] * 9 + x[i] * 10 + x[i] * 11 + x[i] * 12 +
519           x[i] * 13 + x[i] * 14 + x[i] * 15 + x[i] * 1 + x[i] * 2 + x[i] * 3 + x[i] * 4 +
520           x[i] * 5 + x[i] * 6 + x[i] * 7 + x[i] * 8 + x[i] * 9 + x[i] * 10 + x[i] * 11 +
521           x[i] * 12 + x[i] * 13 + x[i] * 14 + x[i] * 15 + x[i] * 1 + x[i] * 2 + x[i] * 3 +
522           x[i] * 4 + x[i] * 5;
523     }
524   }
525 
526   // Mixed of 16-bit and 8-bit array references.
castAndNarrow(byte[] x, char[] y)527   static void castAndNarrow(byte[] x, char[] y) {
528     for (int i = 0; i < x.length; i++) {
529       x[i] = (byte) ((short) y[i] +  1);
530     }
531   }
532 
533   // Avoid bad scheduler-SIMD interaction.
doNotMoveSIMD()534   static int doNotMoveSIMD() {
535     int sum = 0;
536     for (int j = 0; j <= 8; j++) {
537       int[] a = new int[17];    // a[i] = 0;
538                                 // ConstructorFence ?
539       for (int i = 0; i < a.length; i++) {
540         a[i] += 1;              // a[i] = 1;
541       }
542       for (int i = 0; i < a.length; i++) {
543         sum += a[i];            // expect a[i] = 1;
544       }
545     }
546     return sum;
547   }
548 
549   // Ensure spilling saves full SIMD values.
reduction32Values(int[] a, int[] b, int[] c, int[] d)550   private static final int reduction32Values(int[] a, int[] b, int[] c, int[] d) {
551     int s0 = 0;
552     int s1 = 0;
553     int s2 = 0;
554     int s3 = 0;
555     int s4 = 0;
556     int s5 = 0;
557     int s6 = 0;
558     int s7 = 0;
559     int s8 = 0;
560     int s9 = 0;
561     int s10 = 0;
562     int s11 = 0;
563     int s12 = 0;
564     int s13 = 0;
565     int s14 = 0;
566     int s15 = 0;
567     int s16 = 0;
568     int s17 = 0;
569     int s18 = 0;
570     int s19 = 0;
571     int s20 = 0;
572     int s21 = 0;
573     int s22 = 0;
574     int s23 = 0;
575     int s24 = 0;
576     int s25 = 0;
577     int s26 = 0;
578     int s27 = 0;
579     int s28 = 0;
580     int s29 = 0;
581     int s30 = 0;
582     int s31 = 0;
583     for (int i = 1; i < 100; i++) {
584       s0 += a[i];
585       s1 += b[i];
586       s2 += c[i];
587       s3 += d[i];
588       s4 += a[i];
589       s5 += b[i];
590       s6 += c[i];
591       s7 += d[i];
592       s8 += a[i];
593       s9 += b[i];
594       s10 += c[i];
595       s11 += d[i];
596       s12 += a[i];
597       s13 += b[i];
598       s14 += c[i];
599       s15 += d[i];
600       s16 += a[i];
601       s17 += b[i];
602       s18 += c[i];
603       s19 += d[i];
604       s20 += a[i];
605       s21 += b[i];
606       s22 += c[i];
607       s23 += d[i];
608       s24 += a[i];
609       s25 += b[i];
610       s26 += c[i];
611       s27 += d[i];
612       s28 += a[i];
613       s29 += b[i];
614       s30 += c[i];
615       s31 += d[i];
616     }
617     return s0 + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10 + s11 + s12 + s13 + s14 + s15 +
618            s16 + s17 + s18 + s19 + s20 + s21 + s22 + s23 +
619            s24 + s25 + s26 + s27 + s28 + s29 + s30 + s31;
620   }
621 
622   // Ensure spilling saves regular FP values correctly when the graph HasSIMD()
623   // is true.
624   /// CHECK-START-ARM64: float Main.$noinline$ensureSlowPathFPSpillFill(float[], float[], float[], float[], int[]) loop_optimization (after)
625   //
626   //  Both regular and SIMD accesses are present.
627   /// CHECK-DAG: VecLoad
628   /// CHECK-DAG: ArrayGet
$noinline$ensureSlowPathFPSpillFill(float[] a, float[] b, float[] c, float[] d, int[] e)629   private static final float $noinline$ensureSlowPathFPSpillFill(float[] a,
630                                                                  float[] b,
631                                                                  float[] c,
632                                                                  float[] d,
633                                                                  int[] e) {
634     // This loop should be vectorized so the graph->HasSIMD() will be true.
635     // A power-of-2 number of iterations is chosen to avoid peeling/unrolling interference.
636     for (int i = 0; i < 64; i++) {
637       // The actual values of the array elements don't matter, just the
638       // presence of a SIMD loop.
639       e[i]++;
640     }
641 
642     float f0 = 0;
643     float f1 = 0;
644     float f2 = 0;
645     float f3 = 0;
646     float f4 = 0;
647     float f5 = 0;
648     float f6 = 0;
649     float f7 = 0;
650     float f8 = 0;
651     float f9 = 0;
652     float f10 = 0;
653     float f11 = 0;
654     float f12 = 0;
655     float f13 = 0;
656     float f14 = 0;
657     float f15 = 0;
658     float f16 = 0;
659     float f17 = 0;
660     float f18 = 0;
661     float f19 = 0;
662     float f20 = 0;
663     float f21 = 0;
664     float f22 = 0;
665     float f23 = 0;
666     float f24 = 0;
667     float f25 = 0;
668     float f26 = 0;
669     float f27 = 0;
670     float f28 = 0;
671     float f29 = 0;
672     float f30 = 0;
673     float f31 = 0;
674     for (int i = 0; i < 100; i++) {
675       f0 += a[i];
676       f1 += b[i];
677       f2 += c[i];
678       f3 += d[i];
679       f4 += a[i];
680       f5 += b[i];
681       f6 += c[i];
682       f7 += d[i];
683       f8 += a[i];
684       f9 += b[i];
685       f10 += c[i];
686       f11 += d[i];
687       f12 += a[i];
688       f13 += b[i];
689       f14 += c[i];
690       f15 += d[i];
691       f16 += a[i];
692       f17 += b[i];
693       f18 += c[i];
694       f19 += d[i];
695       f20 += a[i];
696       f21 += b[i];
697       f22 += c[i];
698       f23 += d[i];
699       f24 += a[i];
700       f25 += b[i];
701       f26 += c[i];
702       f27 += d[i];
703       f28 += a[i];
704       f29 += b[i];
705       f30 += c[i];
706       f31 += d[i];
707     }
708     return f0 + f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 + f10 + f11 + f12 + f13 + f14 + f15 +
709            f16 + f17 + f18 + f19 + f20 + f21 + f22 + f23 +
710            f24 + f25 + f26 + f27 + f28 + f29 + f30 + f31;
711   }
712 
reductionIntoReplication()713   public static int reductionIntoReplication() {
714     int[] a = { 1, 2, 3, 4 };
715     int x = 0;
716     for (int i = 0; i < 4; i++) {
717       x += a[i];
718     }
719     for (int i = 0; i < 4; i++) {
720       a[i] = x;
721     }
722     return a[3];
723   }
724 
725   // Dot product and SAD vectorization idioms used to have a bug when some
726   // instruction in the loop was visited twice causing a compiler crash.
727   // It happened when two vectorization idioms' matched patterns had a common
728   // sub-expression.
729 
730   // Idioms common sub-expression bug: DotProduct and ArraySet.
731   //
732   /// CHECK-START-ARM64: int Main.testDotProdAndSet(byte[], byte[], byte[]) loop_optimization (after)
733   /// CHECK-DAG:       VecDotProd
734   /// CHECK-DAG:       VecStore
testDotProdAndSet(byte[] a, byte[] b, byte[] c)735   public static final int testDotProdAndSet(byte[] a, byte[] b, byte[] c) {
736     int s = 1;
737     for (int i = 0; i < b.length; i++) {
738       int temp = a[i] * b[i];
739       c[i]= (byte)temp;
740       s += temp;
741     }
742     return s - 1;
743   }
744 
745   // Idioms common sub-expression bug: DotProduct and DotProduct.
746   //
747   /// CHECK-START-ARM64: int Main.testDotProdAndDotProd(byte[], byte[]) loop_optimization (after)
748   /// CHECK-DAG:       VecDotProd
749   /// CHECK-DAG:       VecDotProd
testDotProdAndDotProd(byte[] a, byte[] b)750   public static final int testDotProdAndDotProd(byte[] a, byte[] b) {
751     int s0 = 1;
752     int s1 = 1;
753     for (int i = 0; i < b.length; i++) {
754       int temp = a[i] * b[i];
755       s0 += temp;
756       s1 += temp;
757     }
758     return s0 + s1;
759   }
760 
761   // Idioms common sub-expression bug: SAD and ArraySet.
762   //
763   /// CHECK-START-ARM: int Main.testSADAndSet(int[], int[], int[]) loop_optimization (after)
764   /// CHECK-DAG:       VecSADAccumulate
765   /// CHECK-DAG:       VecStore
766   //
767   /// CHECK-START-ARM64: int Main.testSADAndSet(int[], int[], int[]) loop_optimization (after)
768   /// CHECK-IF:     hasIsaFeature("sve")
769   //
770   //      VecSADAccumulate is not supported for SVE.
771   ///     CHECK-NOT:       VecSADAccumulate
772   //
773   /// CHECK-ELSE:
774   //
775   ///     CHECK-DAG:       VecSADAccumulate
776   ///     CHECK-DAG:       VecStore
777   //
778   /// CHECK-FI:
testSADAndSet(int[] x, int[] y, int[] z)779   public static int testSADAndSet(int[] x, int[] y, int[] z) {
780     int min_length = Math.min(x.length, y.length);
781     int sad = 0;
782     for (int i = 0; i < min_length; i++) {
783       int temp = Math.abs(x[i] - y[i]);
784       z[i] = temp;
785       sad += temp;
786     }
787     return sad;
788   }
789 
790   // Idioms common sub-expression bug: SAD and SAD.
791   /// CHECK-START-ARM: int Main.testSADAndSAD(int[], int[]) loop_optimization (after)
792   /// CHECK-DAG:       VecSADAccumulate
793   /// CHECK-DAG:       VecSADAccumulate
794   //
795   /// CHECK-START-ARM64: int Main.testSADAndSAD(int[], int[]) loop_optimization (after)
796   /// CHECK-IF:     hasIsaFeature("sve")
797   //
798   //      VecSADAccumulate is not supported for SVE.
799   ///     CHECK-NOT:       VecSADAccumulate
800   //
801   /// CHECK-ELSE:
802   //
803   ///     CHECK-DAG:       VecSADAccumulate
804   ///     CHECK-DAG:       VecSADAccumulate
805   //
806   /// CHECK-FI:
testSADAndSAD(int[] x, int[] y)807   public static final int testSADAndSAD(int[] x, int[] y) {
808     int s0 = 1;
809     int s1 = 1;
810     for (int i = 0; i < x.length; i++) {
811       int temp = Math.abs(x[i] - y[i]);
812       s0 += temp;
813       s1 += temp;
814     }
815     return s0 + s1;
816   }
817 
818   // Idioms common sub-expression bug: DotProd and DotProd with extra mul.
819   //
820   /// CHECK-START-ARM64: int Main.testDotProdAndDotProdExtraMul0(byte[], byte[]) loop_optimization (after)
821   /// CHECK-DAG:       VecMul
822   /// CHECK-DAG:       VecDotProd
823   /// CHECK-DAG:       VecDotProd
testDotProdAndDotProdExtraMul0(byte[] a, byte[] b)824   public static final int testDotProdAndDotProdExtraMul0(byte[] a, byte[] b) {
825     int s0 = 1;
826     int s1 = 1;
827     for (int i = 0; i < b.length; i++) {
828       int temp0 = a[i] * b[i];
829       int temp1 = (byte)(temp0) * a[i];
830       s0 += temp1;
831       s1 += temp0;
832     }
833     return s0 + s1;
834   }
835 
836   // Idioms common sub-expression bug: DotProd and DotProd with extra mul (reversed order).
837   //
838   /// CHECK-START-ARM64: int Main.testDotProdAndDotProdExtraMul1(byte[], byte[]) loop_optimization (after)
839   /// CHECK-DAG:       VecMul
840   /// CHECK-DAG:       VecDotProd
841   /// CHECK-DAG:       VecDotProd
testDotProdAndDotProdExtraMul1(byte[] a, byte[] b)842   public static final int testDotProdAndDotProdExtraMul1(byte[] a, byte[] b) {
843     int s0 = 1;
844     int s1 = 1;
845     for (int i = 0; i < b.length; i++) {
846       int temp0 = a[i] * b[i];
847       int temp1 = (byte)(temp0) * a[i];
848       s0 += temp0;
849       s1 += temp1;
850     }
851     return s0 + s1;
852   }
853 
854   // Idioms common sub-expression bug: SAD and SAD with extra abs.
855   //
856   /// CHECK-START-ARM: int Main.testSADAndSADExtraAbs0(int[], int[]) loop_optimization (after)
857   /// CHECK-DAG:       VecSub
858   /// CHECK-DAG:       VecAbs
859   /// CHECK-DAG:       VecSADAccumulate
860   /// CHECK-DAG:       VecSADAccumulate
861   //
862   /// CHECK-START-ARM64: int Main.testSADAndSADExtraAbs0(int[], int[]) loop_optimization (after)
863   /// CHECK-IF:     hasIsaFeature("sve")
864   //
865   //      VecSADAccumulate is not supported for SVE.
866   ///     CHECK-NOT:       VecSADAccumulate
867   //
868   /// CHECK-ELSE:
869   //
870   ///     CHECK-DAG:       VecSub
871   ///     CHECK-DAG:       VecAbs
872   ///     CHECK-DAG:       VecSADAccumulate
873   ///     CHECK-DAG:       VecSADAccumulate
874   //
875   /// CHECK-FI:
testSADAndSADExtraAbs0(int[] x, int[] y)876   public static final int testSADAndSADExtraAbs0(int[] x, int[] y) {
877     int s0 = 1;
878     int s1 = 1;
879     for (int i = 0; i < x.length; i++) {
880       int temp0 = Math.abs(x[i] - y[i]);
881       int temp1 = Math.abs(temp0 - y[i]);
882       s0 += temp1;
883       s1 += temp0;
884     }
885     return s0 + s1;
886   }
887 
888   // Idioms common sub-expression bug: SAD and SAD with extra abs (reversed order).
889   //
890   /// CHECK-START-ARM: int Main.testSADAndSADExtraAbs1(int[], int[]) loop_optimization (after)
891   /// CHECK-DAG:       VecSub
892   /// CHECK-DAG:       VecAbs
893   /// CHECK-DAG:       VecSADAccumulate
894   /// CHECK-DAG:       VecSADAccumulate
895   //
896   /// CHECK-START-ARM64: int Main.testSADAndSADExtraAbs1(int[], int[]) loop_optimization (after)
897   /// CHECK-IF:     hasIsaFeature("sve")
898   //
899   //      VecSADAccumulate is not supported for SVE.
900   ///     CHECK-NOT:       VecSADAccumulate
901   //
902   /// CHECK-ELSE:
903   //
904   ///     CHECK-DAG:       VecSub
905   ///     CHECK-DAG:       VecAbs
906   ///     CHECK-DAG:       VecSADAccumulate
907   ///     CHECK-DAG:       VecSADAccumulate
908   //
909   /// CHECK-FI:
testSADAndSADExtraAbs1(int[] x, int[] y)910   public static final int testSADAndSADExtraAbs1(int[] x, int[] y) {
911     int s0 = 1;
912     int s1 = 1;
913     for (int i = 0; i < x.length; i++) {
914       int temp0 = Math.abs(x[i] - y[i]);
915       int temp1 = Math.abs(temp0 - y[i]);
916       s0 += temp0;
917       s1 += temp1;
918     }
919     return s0 + s1;
920   }
921 
922 
923   // Idioms common sub-expression bug: SAD and DotProd combined.
924   //
925   /// CHECK-START-ARM64: int Main.testSADAndDotProdCombined0(byte[], byte[]) loop_optimization (after)
926   /// CHECK-IF:     hasIsaFeature("sve")
927   //
928   //      VecSADAccumulate is not supported for SVE.
929   ///     CHECK-NOT:       VecSADAccumulate
930   //
931   /// CHECK-ELSE:
932   //
933   ///     CHECK-DAG:       VecSub
934   ///     CHECK-DAG:       VecSADAccumulate
935   ///     CHECK-DAG:       VecDotProd
936   //
937   /// CHECK-FI:
testSADAndDotProdCombined0(byte[] x, byte[] y)938   public static final int testSADAndDotProdCombined0(byte[] x, byte[] y) {
939     int s0 = 1;
940     int s1 = 1;
941     for (int i = 0; i < x.length; i++) {
942       int temp0 = x[i] - y[i];
943       int temp1 = Math.abs(temp0);
944       int temp2 = x[i] * (byte)(temp0);
945 
946       s0 += temp1;
947       s1 += temp2;
948     }
949     return s0 + s1;
950   }
951 
952   // Idioms common sub-expression bug: SAD and DotProd combined (reversed order).
953   /// CHECK-START-ARM64: int Main.testSADAndDotProdCombined1(byte[], byte[]) loop_optimization (after)
954   /// CHECK-IF:     hasIsaFeature("sve")
955   //
956   //      VecSADAccumulate is not supported for SVE.
957   ///     CHECK-NOT:       VecSADAccumulate
958   //
959   /// CHECK-ELSE:
960   //
961   ///     CHECK-DAG:       VecSub
962   ///     CHECK-DAG:       VecSADAccumulate
963   ///     CHECK-DAG:       VecDotProd
964   //
965   /// CHECK-FI:
testSADAndDotProdCombined1(byte[] x, byte[] y)966   public static final int testSADAndDotProdCombined1(byte[] x, byte[] y) {
967     int s0 = 1;
968     int s1 = 1;
969     for (int i = 0; i < x.length; i++) {
970       int temp0 = x[i] - y[i];
971       int temp1 = Math.abs(temp0);
972       int temp2 = x[i] * (byte)(temp0);
973 
974       s0 += temp2;
975       s1 += temp1;
976     }
977     return s0 + s1;
978   }
979 
980   public static final int ARRAY_SIZE = 512;
981 
createAndInitByteArray(int x)982   private static byte[] createAndInitByteArray(int x) {
983     byte[] a = new byte[ARRAY_SIZE];
984     for (int i = 0; i < a.length; i++) {
985       a[i] = (byte)((~i) + x);
986     }
987     return a;
988   }
989 
createAndInitIntArray(int x)990   private static int[] createAndInitIntArray(int x) {
991     int[] a = new int[ARRAY_SIZE];
992     for (int i = 0; i < a.length; i++) {
993       a[i] = (~i) + x;
994     }
995     return a;
996   }
997 
main(String[] args)998   public static void main(String[] args) {
999     System.loadLibrary(args[0]);
1000 
1001     expectEquals(10, earlyExitFirst(-1));
1002     for (int i = 0; i <= 10; i++) {
1003       expectEquals(i, earlyExitFirst(i));
1004     }
1005     expectEquals(10, earlyExitFirst(11));
1006 
1007     expectEquals(10, earlyExitLast(-1));
1008     for (int i = 0; i < 10; i++) {
1009       expectEquals(i + 1, earlyExitLast(i));
1010     }
1011     expectEquals(10, earlyExitLast(10));
1012     expectEquals(10, earlyExitLast(11));
1013 
1014     expectEquals(2, earlyExitNested());
1015 
1016     expectEquals(17, transferNarrowWrap());
1017     expectEquals(-45, polynomialShort());
1018     expectEquals(-45, polynomialIntFromLong());
1019     expectEquals(-45, polynomialInt());
1020 
1021     expectEquals(0, geoIntDivLastValue(0));
1022     expectEquals(0, geoIntDivLastValue(1));
1023     expectEquals(0, geoIntDivLastValue(2));
1024     expectEquals(0, geoIntDivLastValue(1081788608));
1025     expectEquals(0, geoIntDivLastValue(-1081788608));
1026     expectEquals(0, geoIntDivLastValue(2147483647));
1027     expectEquals(0, geoIntDivLastValue(-2147483648));
1028 
1029     expectEquals(          0, geoIntMulLastValue(0));
1030     expectEquals( -194211840, geoIntMulLastValue(1));
1031     expectEquals( -388423680, geoIntMulLastValue(2));
1032     expectEquals(-1041498112, geoIntMulLastValue(1081788608));
1033     expectEquals( 1041498112, geoIntMulLastValue(-1081788608));
1034     expectEquals(  194211840, geoIntMulLastValue(2147483647));
1035     expectEquals(          0, geoIntMulLastValue(-2147483648));
1036 
1037     expectEquals(0L, geoLongDivLastValue(0L));
1038     expectEquals(0L, geoLongDivLastValue(1L));
1039     expectEquals(0L, geoLongDivLastValue(2L));
1040     expectEquals(0L, geoLongDivLastValue(1081788608L));
1041     expectEquals(0L, geoLongDivLastValue(-1081788608L));
1042     expectEquals(0L, geoLongDivLastValue(2147483647L));
1043     expectEquals(0L, geoLongDivLastValue(-2147483648L));
1044     expectEquals(0L, geoLongDivLastValue(9223372036854775807L));
1045     expectEquals(0L, geoLongDivLastValue(-9223372036854775808L));
1046 
1047     expectEquals(0L, geoLongDivLastValue());
1048 
1049     expectEquals(                   0L, geoLongMulLastValue(0L));
1050     expectEquals(-8070450532247928832L, geoLongMulLastValue(1L));
1051     expectEquals( 2305843009213693952L, geoLongMulLastValue(2L));
1052     expectEquals(                   0L, geoLongMulLastValue(1081788608L));
1053     expectEquals(                   0L, geoLongMulLastValue(-1081788608L));
1054     expectEquals( 8070450532247928832L, geoLongMulLastValue(2147483647L));
1055     expectEquals(                   0L, geoLongMulLastValue(-2147483648L));
1056     expectEquals( 8070450532247928832L, geoLongMulLastValue(9223372036854775807L));
1057     expectEquals(                   0L, geoLongMulLastValue(-9223372036854775808L));
1058 
1059     float[] a = new float[16];
1060     narrowingSubscript(a);
1061     for (int i = 0; i < 16; i++) {
1062       expectEquals(2.0f, a[i]);
1063     }
1064 
1065     int[] xx = new int[2];
1066     int[] yy = new int[469];
1067     reduc(xx, yy);
1068     expectEquals(-469, xx[0]);
1069     expectEquals(-938, xx[1]);
1070     for (int i = 0; i < 469; i++) {
1071       expectEquals(2, yy[i]);
1072     }
1073 
1074     char[] aa = new char[23];
1075     String bb = "hello world how are you";
1076     string2Bytes(aa, bb);
1077     for (int i = 0; i < aa.length; i++) {
1078       expectEquals(aa[i], bb.charAt(i));
1079     }
1080     String cc = "\u1010\u2020llo world how are y\u3030\u4040";
1081     string2Bytes(aa, cc);
1082     for (int i = 0; i < aa.length; i++) {
1083       expectEquals(aa[i], cc.charAt(i));
1084     }
1085 
1086     short[] s2s = new short[12];
1087     $noinline$stringToShorts(s2s, "abcdefghijkl");
1088     for (int i = 0; i < s2s.length; ++i) {
1089       expectEquals((short) "abcdefghijkl".charAt(i), s2s[i]);
1090     }
1091 
1092     envUsesInCond();
1093 
1094     short[] dd = new short[23];
1095     oneBoth(dd, aa);
1096     for (int i = 0; i < aa.length; i++) {
1097       expectEquals(aa[i], 1);
1098       expectEquals(dd[i], 1);
1099     }
1100 
1101     xx[0] = 10;
1102     byte[] bt = new byte[10];
1103     arrayInTripCount(xx, bt, 20);
1104     for (int i = 0; i < bt.length; i++) {
1105       expectEquals(40, bt[i]);
1106     }
1107 
1108     byte[] b1 = new byte[259];  // few extra iterations
1109     byte[] b2 = new byte[259];
1110     for (int i = 0; i < 259; i++) {
1111       b1[i] = 0;
1112       b2[i] = (byte) i;
1113     }
1114     typeConv(b1, b2);
1115     for (int i = 0; i < 259; i++) {
1116       expectEquals((byte)(i + 1), b1[i]);
1117     }
1118 
1119     inductionMax(yy);
1120 
1121     int[] f = new int[100];
1122     f[0] = 11;
1123     expectEquals(1000, feedsIntoDeopt(f));
1124     for (int i = 0; i < 100; i++) {
1125       expectEquals(11, f[i]);
1126     }
1127 
1128     expectEquals(0, absCanBeNegative(-3));
1129     expectEquals(3, absCanBeNegative(-2));
1130     expectEquals(5, absCanBeNegative(-1));
1131     expectEquals(6, absCanBeNegative(0));
1132     expectEquals(5, absCanBeNegative(1));
1133     expectEquals(3, absCanBeNegative(2));
1134     expectEquals(0, absCanBeNegative(3));
1135     expectEquals(0, absCanBeNegative(Integer.MAX_VALUE));
1136     // Abs(min_int) = min_int.
1137     int verify = 0;
1138     try {
1139       absCanBeNegative(Integer.MIN_VALUE);
1140       verify = 1;
1141     } catch (ArrayIndexOutOfBoundsException e) {
1142       verify = 2;
1143     }
1144     expectEquals(2, verify);
1145 
1146     int[][] x = new int[128][128];
1147     for (int i = 0; i < 128; i++) {
1148       for (int j = 0; j < 128; j++) {
1149         x[i][j] = -i - j;
1150       }
1151     }
1152     expectEquals(-2080768, sum(x));
1153 
1154     largeBody(f);
1155     for (int i = 0; i < 100; i++) {
1156       expectEquals(2805, f[i]);
1157     }
1158 
1159     char[] cx = new char[259];
1160     for (int i = 0; i < 259; i++) {
1161       cx[i] = (char) (i - 100);
1162     }
1163     castAndNarrow(b1, cx);
1164     for (int i = 0; i < 259; i++) {
1165       expectEquals((byte)((short) cx[i] + 1), b1[i]);
1166     }
1167 
1168     expectEquals(153, doNotMoveSIMD());
1169 
1170     // This test exposed SIMDization issues on x86 and x86_64
1171     // so we make sure the test runs with JIT enabled.
1172     ensureJitCompiled(Main.class, "reduction32Values");
1173     {
1174       int[] a1 = new int[100];
1175       int[] a2 = new int[100];
1176       int[] a3 = new int[100];
1177       int[] a4 = new int[100];
1178       for (int i = 0; i < 100; i++) {
1179         a1[i] = i;
1180         a2[i] = 1;
1181         a3[i] = 100 - i;
1182         a4[i] = i % 16;
1183       }
1184       expectEquals(85800, reduction32Values(a1, a2, a3, a4));
1185     }
1186     {
1187       float[] a1 = new float[100];
1188       float[] a2 = new float[100];
1189       float[] a3 = new float[100];
1190       float[] a4 = new float[100];
1191       int[] a5 = new int[100];
1192 
1193       for (int i = 0; i < 100; i++) {
1194         a1[i] = (float)i;
1195         a2[i] = (float)1;
1196         a3[i] = (float)(100 - i);
1197         a4[i] = (i % 16);
1198       }
1199       expectEquals(86608.0f, $noinline$ensureSlowPathFPSpillFill(a1, a2, a3, a4, a5));
1200     }
1201 
1202     expectEquals(10, reductionIntoReplication());
1203 
1204     {
1205         byte[] b_a = createAndInitByteArray(1);
1206         byte[] b_b = createAndInitByteArray(2);
1207         byte[] b_c = createAndInitByteArray(3);
1208         expectEquals(2731008, testDotProdAndSet(b_a, b_b, b_c));
1209     }
1210     {
1211         byte[] b_a = createAndInitByteArray(1);
1212         byte[] b_b = createAndInitByteArray(2);
1213         expectEquals(5462018, testDotProdAndDotProd(b_a, b_b));
1214     }
1215     {
1216         int[] i_a = createAndInitIntArray(1);
1217         int[] i_b = createAndInitIntArray(2);
1218         int[] i_c = createAndInitIntArray(3);
1219         expectEquals(512, testSADAndSet(i_a, i_b, i_c));
1220     }
1221     {
1222         int[] i_a = createAndInitIntArray(1);
1223         int[] i_b = createAndInitIntArray(2);
1224         expectEquals(1026, testSADAndSAD(i_a, i_b));
1225     }
1226     {
1227         byte[] b_a = createAndInitByteArray(1);
1228         byte[] b_b = createAndInitByteArray(2);
1229         expectEquals(2731266, testDotProdAndDotProdExtraMul0(b_a, b_b));
1230     }
1231     {
1232         byte[] b_a = createAndInitByteArray(1);
1233         byte[] b_b = createAndInitByteArray(2);
1234         expectEquals(2731266, testDotProdAndDotProdExtraMul1(b_a, b_b));
1235     }
1236     {
1237         int[] i_a = createAndInitIntArray(1);
1238         int[] i_b = createAndInitIntArray(2);
1239         expectEquals(131330, testSADAndSADExtraAbs0(i_a, i_b));
1240     }
1241     {
1242         int[] i_a = createAndInitIntArray(1);
1243         int[] i_b = createAndInitIntArray(2);
1244         expectEquals(131330, testSADAndSADExtraAbs1(i_a, i_b));
1245     }
1246     {
1247         byte[] b_a = createAndInitByteArray(1);
1248         byte[] b_b = createAndInitByteArray(2);
1249         expectEquals(1278, testSADAndDotProdCombined0(b_a, b_b));
1250     }
1251     {
1252         byte[] b_a = createAndInitByteArray(1);
1253         byte[] b_b = createAndInitByteArray(2);
1254         expectEquals(1278, testSADAndDotProdCombined1(b_a, b_b));
1255     }
1256 
1257     System.out.println("passed");
1258   }
1259 
expectEquals(int expected, int result)1260   private static void expectEquals(int expected, int result) {
1261     if (expected != result) {
1262       throw new Error("Expected: " + expected + ", found: " + result);
1263     }
1264   }
1265 
expectEquals(long expected, long result)1266   private static void expectEquals(long expected, long result) {
1267     if (expected != result) {
1268       throw new Error("Expected: " + expected + ", found: " + result);
1269     }
1270   }
1271 
expectEquals(float expected, float result)1272   private static void expectEquals(float expected, float result) {
1273     if (expected != result) {
1274       throw new Error("Expected: " + expected + ", found: " + result);
1275     }
1276   }
1277 }
1278