/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
public class Main {
/// CHECK-START: int Main.sieve(int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: int Main.sieve(int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static int sieve(int size) {
int primeCount = 0;
boolean[] flags = new boolean[size + 1];
for (int i = 1; i < size; i++) flags[i] = true; // Can eliminate.
for (int i = 2; i < size; i++) {
if (flags[i]) { // Can eliminate.
primeCount++;
for (int k = i + 1; k <= size; k += i)
flags[k - 1] = false; // Can't eliminate yet due to (k+i) may overflow.
}
}
return primeCount;
}
/// CHECK-START: void Main.narrow(int[], int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.narrow(int[], int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static void narrow(int[] array, int offset) {
if (offset < 0) {
return;
}
if (offset < array.length) {
// offset is in range [0, array.length-1].
// Bounds check can be eliminated.
array[offset] = 1;
int biased_offset1 = offset + 1;
// biased_offset1 is in range [1, array.length].
if (biased_offset1 < array.length) {
// biased_offset1 is in range [1, array.length-1].
// Bounds check can be eliminated.
array[biased_offset1] = 1;
}
int biased_offset2 = offset + 0x70000000;
// biased_offset2 is in range [0x70000000, array.length-1+0x70000000].
// It may overflow and be negative.
if (biased_offset2 < array.length) {
// Even with this test, biased_offset2 can be negative so we can't
// eliminate this bounds check.
array[biased_offset2] = 1;
}
// offset_sub1 won't underflow since offset is no less than 0.
int offset_sub1 = offset - Integer.MAX_VALUE;
if (offset_sub1 >= 0) {
array[offset_sub1] = 1; // Bounds check can be eliminated.
}
// offset_sub2 can underflow.
int offset_sub2 = offset_sub1 - Integer.MAX_VALUE;
if (offset_sub2 >= 0) {
array[offset_sub2] = 1; // Bounds check can't be eliminated.
}
}
}
/// CHECK-START: void Main.constantIndexing1(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing1(int[]) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing1(int[] array) {
// Decreasing order: bc for 5 but not for 4.
array[5] = 11;
array[4] = 11;
}
/// CHECK-START: void Main.$opt$noinline$constantIndexing2(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.$opt$noinline$constantIndexing2(int[]) BCE (after)
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void $opt$noinline$constantIndexing2(int[] array) {
array[1] = 1;
array[2] = 1;
array[3] = 1;
array[4] = 1;
if (array[1] != 1) {
throw new Error("");
}
}
/// CHECK-START: void Main.constantIndexing2b(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing2b(int[]) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing2b(int[] array) {
array[0] = 6;
array[1] = 6;
array[2] = 6;
array[3] = 6;
array[-1] = 1; // prevents the whole opt on [-1:4]
}
/// CHECK-START: void Main.constantIndexing2c(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing2c(int[]) BCE (after)
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing2c(int[] array) {
array[0] = 7;
array[1] = 7;
array[2] = 7;
array[3] = 7;
}
/// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: int[] Main.constantIndexing3(int[], int[], boolean) BCE (after)
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static int[] constantIndexing3(int[] array1, int[] array2, boolean copy) {
if (!copy) {
return array1;
}
array2[0] = array1[0];
array2[1] = array1[1];
array2[2] = array1[2];
array2[3] = array1[3];
return array2;
}
/// CHECK-START: void Main.constantIndexing4(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing4(int[]) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK: BoundsCheck
/// CHECK: ArraySet
// There is only one array access. It's not beneficial
// to create a compare with deoptimization instruction.
static void constantIndexing4(int[] array) {
array[0] = -1;
}
/// CHECK-START: void Main.constantIndexing5(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing5(int[]) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing5(int[] array) {
// We don't apply the deoptimization for very large constant index
// since it's likely to be an anomaly and will throw AIOOBE.
array[Integer.MAX_VALUE - 1000] = 1;
array[Integer.MAX_VALUE - 999] = 1;
array[Integer.MAX_VALUE - 998] = 1;
}
/// CHECK-START: void Main.constantIndexing6(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing6(int[]) BCE (after)
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing6(int[] array) {
array[3] = 111;
array[4] = 111;
}
/// CHECK-START: void Main.constantIndexing7(int[], int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing7(int[], int) BCE (after)
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing7(int[] array, int base) {
// With constant offsets to symbolic base.
array[base] = 10;
array[base + 1] = 20;
array[base + 2] = 30;
array[base + 3] = 40;
}
/// CHECK-START: void Main.constantIndexing8(int[], int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing8(int[], int) BCE (after)
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing8(int[] array, int base) {
// With constant offsets "both ways" to symbolic base.
array[base - 1] = 100;
array[base] = 200;
array[base + 1] = 300;
array[base + 2] = 400;
}
/// CHECK-START: void Main.constantIndexing9(int[], int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing9(int[], int) BCE (after)
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
static void constantIndexing9(int[] array, int base) {
// Final range is base..base+3 so conditional
// references may be included in the end.
array[base] = 0;
if (base != 12345)
array[base + 2] = 2;
array[base + 3] = 3;
if (base != 67890)
array[base + 1] = 1;
}
/// CHECK-START: void Main.constantIndexing10(int[], int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantIndexing10(int[], int) BCE (after)
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void constantIndexing10(int[] array, int base) {
// Offset hidden in incremented base.
array[base] = 1;
array[++base] = 2;
array[++base] = 3;
array[++base] = 4;
}
static void runAllConstantIndices() {
int[] a1 = { 0 };
int[] a6 = { 0, 0, 0, 0, 0, 0 };
boolean caught = false;
try {
constantIndexing1(a1);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught) {
System.out.println("constant indices 1 failed!");
}
constantIndexing1(a6);
if (a6[4] != 11 || a6[5] != 11) {
System.out.println("constant indices 1 failed!");
}
$opt$noinline$constantIndexing2(a6);
if (a6[0] != 0 || a6[1] != 1 || a6[2] != 1 ||
a6[3] != 1 || a6[4] != 1 || a6[5] != 11) {
System.out.println("constant indices 2 failed!");
}
caught = false;
try {
constantIndexing2b(a6);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || a6[0] != 6 || a6[1] != 6 || a6[2] != 6 ||
a6[3] != 6 || a6[4] != 1 || a6[5] != 11) {
System.out.println("constant indices 2b failed!");
}
caught = false;
try {
constantIndexing2c(a1);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || a1[0] != 7) {
System.out.println("constant indices 2c failed!");
}
constantIndexing2c(a6);
if (a6[0] != 7 || a6[1] != 7 || a6[2] != 7 ||
a6[3] != 7 || a6[4] != 1 || a6[5] != 11) {
System.out.println("constant indices 2c failed!");
}
int[] b4 = new int[4];
constantIndexing3(a6, b4, true);
if (b4[0] != 7 || b4[1] != 7 || b4[2] != 7 || b4[3] != 7) {
System.out.println("constant indices 3 failed!");
}
constantIndexing4(a1);
if (a1[0] != -1) {
System.out.println("constant indices 4 failed!");
}
caught = false;
try {
constantIndexing5(a6);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught) {
System.out.println("constant indices 5 failed!");
}
constantIndexing6(a6);
if (a6[0] != 7 || a6[1] != 7 || a6[2] != 7 ||
a6[3] != 111 || a6[4] != 111 || a6[5] != 11) {
System.out.println("constant indices 6 failed!");
}
constantIndexing7(a6, 1);
if (a6[0] != 7 || a6[1] != 10 || a6[2] != 20 ||
a6[3] != 30 || a6[4] != 40 || a6[5] != 11) {
System.out.println("constant indices 7 failed!");
}
caught = false;
try {
constantIndexing7(a6, 5);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || a6[0] != 7 || a6[1] != 10 || a6[2] != 20 ||
a6[3] != 30 || a6[4] != 40 || a6[5] != 10) {
System.out.println("constant indices 7 failed!");
}
constantIndexing8(a6, 1);
if (a6[0] != 100 || a6[1] != 200 || a6[2] != 300 ||
a6[3] != 400 || a6[4] != 40 || a6[5] != 10) {
System.out.println("constant indices 8 failed!");
}
caught = false;
try {
constantIndexing8(a6, 0);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || a6[0] != 100) {
System.out.println("constant indices 8 failed!");
}
constantIndexing9(a6, 0);
if (a6[0] != 0 || a6[1] != 1 || a6[2] != 2 ||
a6[3] != 3 || a6[4] != 40 || a6[5] != 10) {
System.out.println("constant indices 9 failed!");
}
constantIndexing10(a6, 0);
if (a6[0] != 1 || a6[1] != 2 || a6[2] != 3 ||
a6[3] != 4 || a6[4] != 40 || a6[5] != 10) {
System.out.println("constant indices 10 failed!");
}
}
// A helper into which the actual throwing function should be inlined.
static void constantIndexingForward6(int[] array) {
assertIsManaged();
constantIndexing6(array);
}
/// CHECK-START: void Main.loopPattern1(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.loopPattern1(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void loopPattern1(int[] array) {
for (int i = 0; i < array.length; i++) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = 1; i < array.length; i++) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = 1; i < array.length - 1; i++) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = -1; i < array.length; i++) {
array[i] = 1; // Bounds check can't be eliminated.
}
for (int i = 0; i <= array.length; i++) {
array[i] = 1; // Bounds check can't be eliminated.
}
for (int i = 0; i < array.length; i += 2) {
// We don't have any assumption on max array length yet.
// Bounds check can't be eliminated due to overflow concern.
array[i] = 1;
}
for (int i = 1; i < array.length; i += 2) {
// Bounds check can be eliminated since i is odd so the last
// i that's less than array.length is at most (Integer.MAX_VALUE - 2).
array[i] = 1;
}
}
/// CHECK-START: void Main.loopPattern2(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.loopPattern2(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void loopPattern2(int[] array) {
for (int i = array.length - 1; i >= 0; i--) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = array.length; i > 0; i--) {
array[i - 1] = 1; // Bounds check can be eliminated.
}
for (int i = array.length - 1; i > 0; i--) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = array.length; i >= 0; i--) {
array[i] = 1; // Bounds check can't be eliminated.
}
for (int i = array.length; i >= 0; i--) {
array[i - 1] = 1; // Bounds check can't be eliminated.
}
for (int i = array.length; i > 0; i -= 20) {
// For i >= 0, (i - 20 - 1) is guaranteed not to underflow.
array[i - 1] = 1; // Bounds check can be eliminated.
}
}
/// CHECK-START: void Main.loopPattern3(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.loopPattern3(int[]) BCE (after)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static void loopPattern3(int[] array) {
java.util.Random random = new java.util.Random();
for (int i = 0; ; i++) {
if (random.nextInt() % 1000 == 0 && i < array.length) {
// Can't eliminate the bound check since not every i++ is
// matched with a array length check, so there is some chance that i
// overflows and is negative.
array[i] = 1;
}
}
}
/// CHECK-START: void Main.constantNewArray() BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.constantNewArray() BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
static void constantNewArray() {
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = 1; // Bounds check can be eliminated.
}
for (int i = 0; i <= 10; i++) {
array[i] = 1; // Bounds check can't be eliminated.
}
array[0] = 1; // Bounds check can be eliminated.
array[9] = 1; // Bounds check can be eliminated.
array[10] = 1; // Bounds check can't be eliminated.
}
static byte readData() {
return 1;
}
/// CHECK-START: void Main.circularBufferProducer() BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.circularBufferProducer() BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void circularBufferProducer() {
byte[] array = new byte[4096];
int i = 0;
while (true) {
array[i & (array.length - 1)] = readData();
i++;
}
}
/// CHECK-START: void Main.pyramid1(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.pyramid1(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid1(int[] array) {
for (int i = 0; i < (array.length + 1) / 2; i++) {
array[i] = i;
array[array.length - 1 - i] = i;
}
}
/// CHECK-START: void Main.pyramid2(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.pyramid2(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid2(int[] array) {
for (int i = 0; i < (array.length + 1) >> 1; i++) {
array[i] = i;
array[array.length - 1 - i] = i;
}
}
/// CHECK-START: void Main.pyramid3(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.pyramid3(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
// Set array to something like {0, 1, 2, 3, 2, 1, 0}.
static void pyramid3(int[] array) {
for (int i = 0; i < (array.length + 1) >>> 1; i++) {
array[i] = i;
array[array.length - 1 - i] = i;
}
}
/// CHECK-START: boolean Main.isPyramid(int[]) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: boolean Main.isPyramid(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
static boolean isPyramid(int[] array) {
int i = 0;
int j = array.length - 1;
while (i <= j) {
if (array[i] != i) {
return false;
}
if (array[j] != i) {
return false;
}
i++; j--;
}
return true;
}
/// CHECK-START: void Main.modArrayIndex1(int[]) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-START: void Main.modArrayIndex1(int[]) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK-DAG: ArraySet
public static void modArrayIndex1(int[] array) {
for(int i = 0; i < 100; i++) {
// Cannot statically eliminate, for example, when array.length == 5.
// Currently dynamic BCE isn't applied for this case.
array[i % 10] = i;
// Can be eliminated by BCE.
array[i % array.length] = i;
}
}
/// CHECK-START: void Main.modArrayIndex2(int[], int) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-START: void Main.modArrayIndex2(int[], int) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
public static void modArrayIndex2(int array[], int index) {
for(int i = 0; i < 100; i++) {
// Both bounds checks cannot be statically eliminated, because index can be < 0.
// Currently dynamic BCE isn't applied for this case.
array[(index+i) % 10] = i;
array[(index+i) % array.length] = i;
}
}
static final int[] staticArray = new int[10];
/// CHECK-START: void Main.modArrayIndex3() BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-START: void Main.modArrayIndex3() BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK-DAG: ArraySet
public static void modArrayIndex3() {
for(int i = 0; i < 100; i++) {
// Currently dynamic BCE isn't applied for this case.
staticArray[i % 10] = i;
// Can be eliminated by BCE.
staticArray[i % staticArray.length] = i;
}
}
/// CHECK-START: void Main.modArrayIndex4() BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-START: void Main.modArrayIndex4() BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-DAG: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK-DAG: ArraySet
public static void modArrayIndex4() {
int[] array = new int[20];
for(int i = 0; i < 100; i++) {
// The local array length is statically know. Both can be eliminated by BCE.
array[i % 10] = i;
array[i % array.length] = i;
}
}
/// CHECK-START: void Main.modArrayIndex5(int[], int) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: ArraySet
//
/// CHECK-START: void Main.modArrayIndex5(int[], int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-DAG: ArraySet
public static void modArrayIndex5(int[] x, int i) {
while (true) {
int xi = i % x.length;
if (xi < 0)
break;
if (i >= x.length)
break;
x[xi] = i;
i++;
}
}
/// CHECK-START: void Main.bubbleSort(int[]) GVN (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.bubbleSort(int[]) GVN (after)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: ArrayGet
/// CHECK-NOT: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.bubbleSort(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: ArrayGet
/// CHECK-NOT: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
}
/// CHECK-START: void Main.nonzeroLength(int[]) BCE (before)
/// CHECK-DAG: BoundsCheck
//
/// CHECK-START: void Main.nonzeroLength(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void nonzeroLength(int[] a) {
if (a.length != 0) {
a[0] = 112;
}
}
/// CHECK-START: void Main.knownLength(int[]) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
//
/// CHECK-START: void Main.knownLength(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void knownLength(int[] a) {
if (a.length == 2) {
a[0] = -1;
a[1] = -2;
}
}
/// CHECK-START: void Main.lengthAlias1(int[], int) BCE (before)
/// CHECK-DAG: <<Arr:l\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Par:i\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Nul:l\d+>> NullCheck [<<Arr>>] loop:none
/// CHECK-DAG: <<Len:i\d+>> ArrayLength [<<Nul>>] loop:none
/// CHECK-DAG: NotEqual [<<Par>>,<<Len>>] loop:none
/// CHECK-DAG: <<Idx:i\d+>> Phi loop:<<Loop:B\d+>>
/// CHECK-DAG: BoundsCheck [<<Idx>>,<<Len>>] loop:<<Loop>>
//
/// CHECK-START: void Main.lengthAlias1(int[], int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void lengthAlias1(int[] a, int len) {
if (len == a.length) {
for (int i = 0; i < len; i++) {
a[i] = 1;
}
}
}
/// CHECK-START: void Main.lengthAlias2(int[], int) BCE (before)
/// CHECK-DAG: <<Arr:l\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Par:i\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Nul:l\d+>> NullCheck [<<Arr>>] loop:none
/// CHECK-DAG: <<Len:i\d+>> ArrayLength [<<Nul>>] loop:none
/// CHECK-DAG: Equal [<<Par>>,<<Len>>] loop:none
/// CHECK-DAG: <<Idx:i\d+>> Phi loop:<<Loop:B\d+>>
/// CHECK-DAG: BoundsCheck [<<Idx>>,<<Len>>] loop:<<Loop>>
//
/// CHECK-START: void Main.lengthAlias2(int[], int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void lengthAlias2(int[] a, int len) {
if (len != a.length) {
return;
}
for (int i = 0; i < len; i++) {
a[i] = 2;
}
}
/// CHECK-START: void Main.lengthAlias3(int[], int) BCE (before)
/// CHECK-DAG: <<Arr:l\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Par:i\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Nul:l\d+>> NullCheck [<<Arr>>] loop:none
/// CHECK-DAG: <<Len:i\d+>> ArrayLength [<<Nul>>] loop:none
/// CHECK-DAG: NotEqual [<<Par>>,<<Len>>] loop:none
/// CHECK-DAG: <<Idx:i\d+>> Phi loop:<<Loop:B\d+>>
/// CHECK-DAG: BoundsCheck [<<Idx>>,<<Len>>] loop:<<Loop>>
//
/// CHECK-START: void Main.lengthAlias3(int[], int) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void lengthAlias3(int[] a, int len) {
if (a.length == len) {
for (int i = 0; i < len; i++) {
a[i] = 3;
}
}
}
/// CHECK-START: void Main.lengthAlias4(int[]) BCE (before)
/// CHECK-DAG: <<Arr:l\d+>> ParameterValue loop:none
/// CHECK-DAG: <<Val:i\d+>> IntConstant 8 loop:none
/// CHECK-DAG: <<Nul:l\d+>> NullCheck [<<Arr>>] loop:none
/// CHECK-DAG: <<Len:i\d+>> ArrayLength [<<Nul>>] loop:none
/// CHECK-DAG: Equal [<<Len>>,<<Val>>] loop:none
/// CHECK-DAG: <<Idx:i\d+>> Phi loop:<<Loop:B\d+>>
/// CHECK-DAG: BoundsCheck [<<Idx>>,<<Len>>] loop:<<Loop>>
//
/// CHECK-START: void Main.lengthAlias4(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK-NOT: Deoptimize
public static void lengthAlias4(int[] a) {
if (8 != a.length) {
return;
}
for (int i = 0; i < 8; i++) {
a[i] = 4;
}
}
static int[][] mA;
/// CHECK-START: void Main.dynamicBCEAndIntrinsic(int) BCE (before)
// Array references mA[i] and ..[j] both in inner loop.
/// CHECK-DAG: <<Get1:l\d+>> ArrayGet [<<Array1:l\d+>>,<<Bounds1:i\d+>>] loop:<<InnerLoop:B\d+>>
/// CHECK-DAG: <<Array1>> NullCheck [<<Field1:l\d+>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Len1:i\d+>> ArrayLength [<<Array1>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Bounds1>> BoundsCheck [<<Index1:i\d+>>,<<Len1>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Get2:i\d+>> ArrayGet [<<Array2:l\d+>>,<<Bounds2:i\d+>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Array2>> NullCheck [<<Get1>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Len2:i\d+>> ArrayLength [<<Array2>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Bounds2>> BoundsCheck [<<Index2:i\d+>>,<<Len2>>] loop:<<InnerLoop>>
/// CHECK-DAG: Abs [<<Get2>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Index2>> Phi loop:<<InnerLoop>>
/// CHECK-DAG: <<Index1>> Phi loop:<<OuterLoop:B\d+>>
/// CHECK-DAG: <<Field1>> StaticFieldGet loop:none
/// CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
//
/// CHECK-START: void Main.dynamicBCEAndIntrinsic(int) BCE (after)
// Array reference mA[i] hoisted to same level as deopt.
/// CHECK-DAG: Deoptimize loop:<<OuterLoop:B\d+>>
/// CHECK-DAG: ArrayLength loop:<<OuterLoop>>
/// CHECK-DAG: <<Get1:l\d+>> ArrayGet [<<Array1:l\d+>>,<<Index1:i\d+>>] loop:<<OuterLoop>>
// Array reference ..[j] still in inner loop, with a direct index.
/// CHECK-DAG: <<Get2:i\d+>> ArrayGet [<<Array2:l\d+>>,<<Index2:i\d+>>] loop:<<InnerLoop:B\d+>>
/// CHECK-DAG: Abs [<<Get2>>] loop:<<InnerLoop>>
/// CHECK-DAG: <<Index2>> Phi loop:<<InnerLoop>>
/// CHECK-DAG: <<Index1>> Phi loop:<<OuterLoop>>
// Synthetic phi.
/// CHECK-DAG: <<Array2>> Phi loop:<<OuterLoop>>
/// CHECK-DAG: <<Array1>> StaticFieldGet loop:none
/// CHECK-EVAL: "<<InnerLoop>>" != "<<OuterLoop>>"
//
/// CHECK-START: void Main.dynamicBCEAndIntrinsic(int) BCE (after)
/// CHECK-NOT: NullCheck
/// CHECK-NOT: BoundsCheck
static void dynamicBCEAndIntrinsic(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
// Since intrinsic call cannot modify fields or arrays,
// dynamic BCE and hoisting can be applied to the inner loop.
mA[i][j] = Math.abs(mA[i][j]);
}
}
}
static int foo() {
try {
assertIsManaged();
// This will cause AIOOBE.
$opt$noinline$constantIndexing2(new int[3]);
} catch (ArrayIndexOutOfBoundsException e) {
assertIsManaged(); // This is to ensure that single-frame deoptimization works.
// Will need to be updated if $opt$noinline$constantIndexing2 is inlined.
try {
// This will cause AIOOBE.
constantIndexingForward6(new int[3]);
} catch (ArrayIndexOutOfBoundsException e2) {
// Having deopted, we expect to be running interpreted at this point.
// Does not apply to debuggable, however, since we do not inline.
return 99;
}
}
return 0;
}
int sum;
/// CHECK-START: void Main.foo1(int[], int, int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo1(int[], int, int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo1(int[] array, int start, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
// Three HDeoptimize will be added. Two for the index
// and one for null check on array (to hoist null
// check and array.length out of loop).
for (int i = start ; i < end; i++) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
array[i] = 1;
sum += array[i];
}
}
/// CHECK-START: void Main.foo2(int[], int, int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo2(int[], int, int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo2(int[] array, int start, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
// Three HDeoptimize will be added. Two for the index
// and one for null check on array (to hoist null
// check and array.length out of loop).
for (int i = start ; i <= end; i++) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
array[i] = 1;
sum += array[i];
}
}
/// CHECK-START: void Main.foo3(int[], int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo3(int[], int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo3(int[] array, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
// Three HDeoptimize will be added. Two for the index
// and one for null check on array (to hoist null check
// and array.length out of loop).
for (int i = 3 ; i <= end; i++) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
array[i] = 1;
sum += array[i];
}
}
/// CHECK-START: void Main.foo4(int[], int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo4(int[], int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo4(int[] array, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
// Three HDeoptimize will be added. Two for the index
// and one for null check on array (to hoist null check
// and array.length out of loop).
for (int i = end ; i > 0; i--) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
array[i - 1] = 1;
sum += array[i - 1];
}
}
/// CHECK-START: void Main.foo5(int[], int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo5(int[], int, boolean) BCE (after)
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo5(int[] array, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
// Bounds check in this loop can be eliminated without deoptimization.
for (int i = array.length - 1 ; i >= 0; i--) {
array[i] = 1;
}
// Three HDeoptimize will be added for the bounds.
// The null check is not necessary.
for (int i = end - 2 ; i > 0; i--) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
sum += array[i - 1];
sum += array[i];
sum += array[i + 1];
}
}
/// CHECK-START: void Main.foo6(int[], int, int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.foo6(int[], int, int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo6(int[] array, int start, int end, boolean expectInterpreter) {
if (end < 0)
throw new Error("");
for (int i = end; i >= start; i--) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
array[i] = (array[i-2] + array[i-1] + array[i] + array[i+1] + array[i+2]) / 5;
}
}
/// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo7(int[], int, int, boolean) BCE (after)
/// CHECK: Phi
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo7(int[] array, int start, int end, boolean lowEnd) {
// Three HDeoptimize will be added. One for the index
// and one for null check on array (to hoist null
// check and array.length out of loop).
for (int i = start ; i < end; i++) {
if (lowEnd) {
// This array access isn't certain. So we don't
// use +1000 offset in decision making for deoptimization
// conditions.
sum += array[i + 1000];
}
sum += array[i];
}
}
/// CHECK-START: void Main.foo8(int[][], int, int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.foo8(int[][], int, int) BCE (after)
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK: Phi
/// CHECK-NOT: BoundsCheck
/// CHECK: ArraySet
// Added blocks at end for deoptimization.
/// CHECK: Exit
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: If
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Goto
/// CHECK: Goto
/// CHECK: Goto
void foo8(int[][] matrix, int start, int end) {
// Three HDeoptimize will be added for the outer loop,
// two for the index, and null check on matrix. Same
// for the inner loop.
for (int i = start; i < end; i++) {
int[] row = matrix[i];
for (int j = start; j < end; j++) {
row[j] = 1;
}
}
}
/// CHECK-START: void Main.foo9(int[], boolean) BCE (before)
/// CHECK: NullCheck
/// CHECK: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo9(int[], boolean) BCE (after)
// The loop is guaranteed to be entered. No need to transform the
// loop for loop body entry test.
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
/// CHECK: Phi
/// CHECK-NOT: NullCheck
/// CHECK-NOT: BoundsCheck
/// CHECK: ArrayGet
/// CHECK-START: void Main.foo9(int[], boolean) instruction_simplifier$after_bce (after)
// Simplification removes the redundant check
/// CHECK: Deoptimize
/// CHECK: Deoptimize
/// CHECK-NOT: Deoptimize
void foo9(int[] array, boolean expectInterpreter) {
// Three HDeoptimize will be added. Two for the index and one for null check on array. Then
// simplification removes one redundant HDeoptimize.
for (int i = 0 ; i < 10; i++) {
if (expectInterpreter) {
assertIsInterpreted();
} else {
assertIsManaged();
}
sum += array[i];
}
}
/// CHECK-START: void Main.partialLooping(int[], int, int) BCE (before)
/// CHECK: BoundsCheck
/// CHECK: ArraySet
/// CHECK-START: void Main.partialLooping(int[], int, int) BCE (after)
/// CHECK-NOT: Deoptimize
/// CHECK: BoundsCheck
/// CHECK: ArraySet
void partialLooping(int[] array, int start, int end) {
// This loop doesn't cover the full range of [start, end) so
// adding deoptimization is too aggressive, since end can be
// greater than array.length but the loop is never going to work on
// more than 2 elements.
for (int i = start; i < end; i++) {
if (i == 2) {
return;
}
array[i] = 1;
}
}
static void testUnknownBounds() {
boolean caught = false;
runAllConstantIndices();
Main main = new Main();
main.foo1(new int[10], 0, 10, false);
if (main.sum != 10) {
System.out.println("foo1 failed!");
}
caught = false;
main = new Main();
try {
main.foo1(new int[10], 0, 11, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || main.sum != 10) {
System.out.println("foo1 exception failed!");
}
main = new Main();
main.foo2(new int[10], 0, 9, false);
if (main.sum != 10) {
System.out.println("foo2 failed!");
}
caught = false;
main = new Main();
try {
main.foo2(new int[10], 0, 10, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || main.sum != 10) {
System.out.println("foo2 exception failed!");
}
main = new Main();
main.foo3(new int[10], 9, false);
if (main.sum != 7) {
System.out.println("foo3 failed!");
}
caught = false;
main = new Main();
try {
main.foo3(new int[10], 10, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || main.sum != 7) {
System.out.println("foo3 exception failed!");
}
main = new Main();
main.foo4(new int[10], 10, false);
if (main.sum != 10) {
System.out.println("foo4 failed!");
}
caught = false;
main = new Main();
try {
main.foo4(new int[10], 11, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || main.sum != 0) {
System.out.println("foo4 exception failed!");
}
main = new Main();
main.foo5(new int[10], 10, false);
if (main.sum != 24) {
System.out.println("foo5 failed!");
}
caught = false;
main = new Main();
try {
main.foo5(new int[10], 11, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught || main.sum != 2) {
System.out.println("foo5 exception failed!");
}
main = new Main();
main.foo6(new int[10], 2, 7, false);
main = new Main();
int[] array9 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
main.foo9(array9, false);
if (main.sum != 45) {
System.out.println("foo9 failed!");
}
main = new Main();
int[] array = new int[4];
main.partialLooping(new int[3], 0, 4);
if ((array[0] != 1) && (array[1] != 1) &&
(array[2] != 0) && (array[3] != 0)) {
System.out.println("partialLooping failed!");
}
caught = false;
main = new Main();
try {
main.foo6(new int[10], 2, 8, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught) {
System.out.println("foo6 exception failed!");
}
caught = false;
main = new Main();
try {
main.foo6(new int[10], 1, 7, true);
} catch (ArrayIndexOutOfBoundsException e) {
caught = true;
}
if (!caught) {
System.out.println("foo6 exception failed!");
}
}
public void testExceptionMessage() {
short[] B1 = new short[5];
int[] B2 = new int[5];
Exception err = null;
try {
testExceptionMessage1(B1, B2, null, -1, 6);
} catch (Exception e) {
err = e;
}
System.out.println(err);
}
void testExceptionMessage1(short[] a1, int[] a2, long a3[], int start, int finish) {
int j = finish + 77;
// Bug: 22665511
// A deoptimization will be triggered here right before the loop. Need to make
// sure the value of j is preserved for the interpreter.
for (int i = start; i <= finish; i++) {
a2[j - 1] = a1[i + 1];
}
}
// Make sure this method is compiled with optimizing.
/// CHECK-START: void Main.main(java.lang.String[]) register (after)
/// CHECK: ParallelMove
public static void main(String[] args) {
System.loadLibrary(args[0]);
if (!compiledWithOptimizing() ||
!hasOatFile() ||
runtimeIsSoftFail() ||
isInterpreted()) {
disableStackFrameAsserts();
}
sieve(20);
int[] x1 = new int[10];
int[] x2 = new int[10];
int[] x3 = new int[10];
modArrayIndex5(x1, -1);
modArrayIndex5(x2, 0);
modArrayIndex5(x3, 5);
for (int i = 0; i < 10; i++) {
int e1 = 0;
int e2 = i;
int e3 = i < 5 ? 0 : i;
if (x1[i] != e1 || x2[i] != e2 || x3[i] != e3) {
System.out.println("modarray failed!");
}
}
int[] array = {5, 2, 3, 7, 0, 1, 6, 4};
bubbleSort(array);
for (int i = 0; i < 8; i++) {
if (array[i] != i) {
System.out.println("bubble sort failed!");
}
}
nonzeroLength(array);
if (array[0] != 112) {
System.out.println("nonzero length failed!");
}
knownLength(array);
if (array[0] != 112 || array[1] != 1) {
System.out.println("nonzero length failed!");
}
array = new int[2];
knownLength(array);
if (array[0] != -1 || array[1] != -2) {
System.out.println("nonzero length failed!");
}
array = new int[8];
lengthAlias1(array, 8);
for (int i = 0; i < 8; i++) {
if (array[i] != 1) {
System.out.println("alias1 failed!");
}
}
lengthAlias2(array, 8);
for (int i = 0; i < 8; i++) {
if (array[i] != 2) {
System.out.println("alias2 failed!");
}
}
lengthAlias3(array, 8);
for (int i = 0; i < 8; i++) {
if (array[i] != 3) {
System.out.println("alias3 failed!");
}
}
lengthAlias4(array);
for (int i = 0; i < 8; i++) {
if (array[i] != 4) {
System.out.println("alias4 failed!");
}
}
array = new int[10];
lengthAlias1(array, /*mismatched value*/ 8);
lengthAlias2(array, /*mismatched value*/ 8);
lengthAlias3(array, /*mismatched value*/ 8);
lengthAlias4(array); // implicit mismatch
for (int i = 0; i < 10; i++) {
if (array[i] != 0) {
System.out.println("mismatch failed!");
}
}
// Zero length array does not break.
array = new int[0];
nonzeroLength(array);
knownLength(array);
lengthAlias1(array, 0);
lengthAlias2(array, 0);
lengthAlias3(array, 0);
mA = new int[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
mA[i][j] = -1;
}
}
dynamicBCEAndIntrinsic(4);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (mA[i][i] != 1) {
System.out.println("dynamic bce failed!");
}
}
}
array = new int[7];
pyramid1(array);
if (!isPyramid(array)) {
System.out.println("pyramid1 failed!");
}
array = new int[8];
pyramid2(array);
if (!isPyramid(array)) {
System.out.println("pyramid2 failed!");
}
java.util.Arrays.fill(array, -1);
pyramid3(array);
if (!isPyramid(array)) {
System.out.println("pyramid3 failed!");
}
// Make sure this value is kept after deoptimization.
int i = 1;
if (foo() + i != 100) {
System.out.println("foo failed!");
};
testUnknownBounds();
new Main().testExceptionMessage();
}
public static native boolean compiledWithOptimizing();
public static native void disableStackFrameAsserts();
public static native void assertIsManaged();
public static native void assertIsInterpreted();
public static native boolean hasOatFile();
public static native boolean runtimeIsSoftFail();
public static native boolean isInterpreted();
}