/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @bug 8290850
* @summary Test cloning of pinned phi input nodes in create_new_if_for_predicate().
* @run main/othervm -Xcomp -XX:CompileCommand=compileonly,compiler.loopopts.TestCreateNewIfForPredicateCloning::*
* compiler.loopopts.TestCreateNewIfForPredicateCloning
*/
package compiler.loopopts;
public class TestCreateNewIfForPredicateCloning {
static int iFld, iFld2, iFld3, nonZero = 2, nonZero2 = 3;
static boolean bFld = true, bFld2 = false;
static int[] iArrFld = new int[100];
public static void main(String[] args) {
try {
testUnswitching();
testLoopPredicatation();
testLoopPredicatationComplex();
testUnswitchingWithPredicates();
testUnswitchingWithPredicatesDiv();
testFuzzer1();
testFuzzer2();
testFuzzer3();
} catch (Exception e) {
// Expected
}
}
// Test case for the already fixed problem in 8271954: Calling create_new_if_for_predicate in
// clone_predicate_to_unswitched_loop(). This does not crash anymore. But still use it as sanity test here with the
// new fix.
static void testUnswitching() {
int x = 3;
// Block to delay precise type information to after CCP.
int limit = 2;
int constantAfterCCP = 2;
for (; limit < 4; limit *= 2);
for (int i = 2; i < limit; i++) {
constantAfterCCP = 6; // Only known to be constant 6 after CCP.
}
for (int i = 51; i > 9; i -= 3) {
if (bFld) {
x *= 6;
}
// (1) after unswitching:
// if (bFld) {...}
// Since we have a back to back if now with the same condition, we can merge them together by using the
// split if optimization. That will create phi nodes for the UCT regions. Whenever we then call
// create_new_if_for_predicate(), we would just reuse the old phi input for the newly create uncommon trap
// projection. This is done when unswitching again to clone the predicates to the fast and slow loop. But
// in the meantime, we have sunk x out of the loop with CastII nodes which are pinned on the old uncommon
// trap projections. Just reusing these data nodes on the new uncommon trap proj leads to a broken graph:
// the LCA of the old and new uncommon projection would be above the early control (control input of the
// CastII nodes).
//
// 8271954 fixes this when calling create_new_if_for_predicate() in
// clone_predicate_to_unswitched_loop().
x -= 5;
for (int j = 1; j < 10; j++) {
if (bFld) { // Unswitching on bFld such that this condition is moved to (1)
continue;
}
x = 34; // Redefine x such that x is only used in UCT before this loop after split if.
int y = 34;
if (constantAfterCCP == 2) {
// Known to be never taken after CCP, so y will always be 34.
y = 35;
}
if (y == iFld) { // Folds to 34 == iFld after CCP and trigger another unswitching
continue;
}
iFld3 = 34; // Just another statement sucht that the second round of unswitching is done
}
}
// This loop is only needed to delay the second round of unswitching for the inner loop above.
for (int i = 0; i < iArrFld.length; i++) {
iArrFld[i] = 3;
}
}
// Similar to testUnswitching() but we are calling create_new_if_for_predicate in Loop Predication for:
// - Creating hoised range check predicate and skeleton predicate
// - Creating invariant check predicate
// which leads to a crash.
static void testLoopPredicatation() {
int x = 3;
// Block to delay precise type information to after CCP.
int limit = 2;
int constantAfterCCP = 2;
for (; limit < 4; limit *= 2);
for (int i = 2; i < limit; i++) {
constantAfterCCP = 6; // Only known to be constant 6 after CCP.
}
for (int i = 51; i > 9; i -= 3) {
if (bFld) {
x *= 6;
}
// (1) after unswitching:
// if (bFld) {...}
// Since we have a back to back if now with the same condition, we can merge them together by using the
// split if optimization. That will create phi nodes for the UCT regions. Whenever we then call
// create_new_if_for_predicate(), we would just reuse the old phi input for the newly create uncommon trap
// projection. This is done when unswitching again to clone the predicates to the fast and slow loop. But
// in the meantime, we have sunk x out of the loop with CastII nodes which are pinned on the old uncommon
// trap projections. Just reusing these data nodes on the new uncommon trap proj leads to a broken graph:
// the LCA of the old and new uncommon projection would be above the early control (control input of the
// CastII nodes).
x -= 5;
for (int j = 1; j < 10; j++) {
if (bFld) { // Unswitching on bFld such that this condition is moved to (1)
continue;
}
x = 34; // Redefine x such that x is only used in UCT before this loop after split if.
int y = iArrFld[j]; // Range check and null check will be hoisted after Unswitching and split if.
}
}
// This loop is only needed to delay the second round of unswitching for the inner loop above.
for (int i = 0; i < iArrFld.length; i++) {
iArrFld[i] = 3;
}
}
// Similar to testLoopPredicatation() but we are adding some computations for x such that we sink more nodes which
// need to be cloned when calling create_new_if_for_predicate().
static void testLoopPredicatationComplex() {
int x = 3;
// Block to delay precise type information to after CCP.
int limit = 2;
int constantAfterCCP = 2;
for (; limit < 4; limit *= 2);
for (int i = 2; i < limit; i++) {
constantAfterCCP = 6; // Only known to be constant 6 after CCP.
}
for (int i = 51; i > 9; i -= 3) {
if (bFld) {
x *= 6;
}
// (1) after unswitching:
// if (bFld) {...}
// Since we have a back to back if now with the same condition, we can merge them together by using the
// split if optimization. That will create phi nodes for the UCT regions. Whenever we then call
// create_new_if_for_predicate(), we would just reuse the old phi input for the newly create uncommon trap
// projection. This is done when unswitching again to clone the predicates to the fast and slow loop. But
// in the meantime, we have sunk x out of the loop with CastII nodes which are pinned on the old uncommon
// trap projections. Just reusing these data nodes on the new uncommon trap proj leads to a broken graph:
// the LCA of the old and new uncommon projection would be above the early control (control input of the
// CastII nodes).
x -= 5;
// Add some more computations such that more nodes are sunk and therefore more nodes need to be cloned in
// create_new_if_for_predicate().
double d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
d1 = 5 + (double) x;
x = (int)((d1 + iFld2) - (d1 + iFld));
for (int j = 1; j < 10; j++) {
if (bFld) { // Unswitching on bFld such that this condition is moved to (1)
continue;
}
x = 34; // Redefine x such that x is only used in UCT before this loop after split if.
int y = iArrFld[j]; // Range check and null check will be hoisted after Unswitching and split if.
}
}
// This loop is only needed to delay the second round of unswitching for the inner loop above.
for (int i = 0; i < iArrFld.length; i++) {
iArrFld[i] = 3;
}
}
// Combination of testUnswitching() and testLoopPredicatation(): After creating predicates in loop predication,
// we perform another round of loop unswitching where we additionally call create_new_if_for_predicate in
// clone_skeleton_predicate_for_unswitched_loops() which currently leads to a crash.
static void testUnswitchingWithPredicates() {
int x = 3;
if (iArrFld == null) {
// Makes sure to get rid of null check for iArrFld to only create range check predicate
return;
}
// Block to delay precise type information to after CCP.
int limit = 2;
int constantAfterCCP = 2;
for (; limit < 4; limit *= 2);
for (int i = 2; i < limit; i++) {
constantAfterCCP = 6; // Only known to be constant 6 after CCP.
}
for (int i = 51; i > 9; i -= 3) {
if (bFld) {
x *= 6;
}
// (1) after unswitching:
// if (bFld) {...}
// Since we have a back to back if now with the same condition, we can merge them together by using the
// split if optimization. That will create phi nodes for the UCT regions. Whenever we then call
// create_new_if_for_predicate(), we would just reuse the old phi input for the newly create uncommon trap
// projection. This is done when unswitching again to clone the predicates to the fast and slow loop. But
// in the meantime, we have sunk x out of the loop with CastII nodes which are pinned on the old uncommon
// trap projections. Just reusing these data nodes on the new uncommon trap proj leads to a broken graph:
// the LCA of the old and new uncommon projection would be above the early control (control input of the
// CastII nodes).
x -= 5;
for (int j = 1; j < 10; j++) {
if (bFld) { // Unswitching on bFld such that this condition is moved to (1)
continue;
}
x = 34; // Redefine x such that x is only used in UCT before this loop after split if.
int z = iArrFld[j]; // Range check and null check will be hoisted after Unswitching and split if.
int y = 34;
if (constantAfterCCP == 2) {
// Known to be never taken after CCP, so y will always be 34.
y = 35;
}
if (y == iFld) { // Folds to 34 == iFld after CCP and trigger another unswitching
continue;
}
iFld3 = 34; // Just another statement sucht that the second round of unswitching is done
}
}
// This loop is only needed to delay the second round of unswitching for the inner loop above.
for (int i = 0; i < iArrFld.length; i++) {
iArrFld[i] = 3;
}
}
// Same as testUnswitchingWithPredicates() but with a DivI node which has a control input which needs
// to be rewired as well.
static void testUnswitchingWithPredicatesDiv() {
int x = 3;
if (iArrFld == null) {
// Makes sure to get rid of null check for iArrFld to only create range check predicate
return;
}
// Block to delay precise type information to after CCP.
int limit = 2;
int constantAfterCCP = 2;
for (; limit < 4; limit *= 2);
for (int i = 2; i < limit; i++) {
constantAfterCCP = 6; // Only known to be constant 6 after CCP.
}
for (int i = 51; i > 9; i -= 3) {
if (bFld) {
x *= 6;
}
// (1) after unswitching:
// if (bFld) {...}
// Since we have a back to back if now with the same condition, we can merge them together by using the
// split if optimization. That will create phi nodes for the UCT regions. Whenever we then call
// create_new_if_for_predicate(), we would just reuse the old phi input for the newly create uncommon trap
// projection. This is done when unswitching again to clone the predicates to the fast and slow loop. But
// in the meantime, we have sunk x out of the loop with CastII nodes which are pinned on the old uncommon
// trap projections. Just reusing these data nodes on the new uncommon trap proj leads to a broken graph:
// the LCA of the old and new uncommon projection would be above the early control (control input of the
// CastII nodes).
x -= 5;
double d = 5.5f + (double) x;
int a = (int)d;
x = (a / nonZero) - (a / nonZero2);
for (int j = 1; j < 10; j++) {
if (bFld) { // Unswitching on bFld such that this condition is moved to (1)
continue;
}
x = 34; // Redefine x such that x is only used in UCT before this loop after split if.
int z = iArrFld[j]; // Range check and null check will be hoisted after Unswitching and split if.
int y = 34;
if (constantAfterCCP == 2) {
// Known to be never taken after CCP, so y will always be 34.
y = 35;
}
if (y == iFld) { // Folds to 34 == iFld after CCP and trigger another unswitching
continue;
}
iFld3 = 34; // Just another statement sucht that the second round of unswitching is done
}
}
// This loop is only needed to delay the second round of unswitching for the inner loop above.
for (int i = 0; i < iArrFld.length; i++) {
iArrFld[i] = 3;
}
}
static void testFuzzer1() {
int x = 0;
int[] iArr = new int[400];
boolean b = true;
long[] lArr = new long[400];
for (long l1 : lArr) {
for (int i = 63; i > 1; i -= 3) {
for (int j = 1; j < 4; j++) {
if (!b) {
x -= 5;
}
}
for (int j = 1; j < 4; j++) {
if (!b) {
x = iArr[j];
}
if (i == 0) {
l1 += 5;
}
}
}
}
}
static void testFuzzer2() {
int i, i1, i17 = 6, i18;
short s1;
boolean b2 = true;
float f3;
long lArr[][] = new long[400][];
byte byArrFld[] = new byte[4];
i = 1;
do {
for (i1 = 14; 6 < i1; i1--)
;
i17 -= i18 = 1;
while (i18 < 4) {
i18 <<= i17 = 2;
switch (i1) {
case 114:
s1 = byArrFld[1];
break;
case 116:
lArr[1][i18] = iFld;
if (b2)
continue;
case 118:
f3 = iFld;
}
}
i++;
} while (i < 10000);
}
static void testFuzzer3() {
int x = 8;
int y = 4;
for (int i : iArrFld) {
x += 2;
if (bFld) {
x = 3;
} else {
y = 2;
}
for (int j = 0; j < 10; j++) {
x = 0;
y += 5;
if (!bFld) {
iArrFld[1] = 5;
}
}
}
}
}