294 lines
11 KiB
Java
294 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
|
|
* Copyright (c) 2022, Arm Limited. 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.
|
|
*/
|
|
package compiler.c2.irTests;
|
|
|
|
import jdk.test.lib.Asserts;
|
|
import compiler.lib.ir_framework.*;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8290248 8312547
|
|
* @summary Test that Ideal transformations of MaxINode and MinINode are
|
|
* being performed as expected.
|
|
* @library /test/lib /
|
|
* @run driver compiler.c2.irTests.MaxMinINodeIdealizationTests
|
|
*/
|
|
|
|
public class MaxMinINodeIdealizationTests {
|
|
public static void main(String[] args) {
|
|
TestFramework.run();
|
|
}
|
|
|
|
@Run(test = {"testMax1LL", "testMax1LR", "testMax1RL", "testMax1RR",
|
|
"testMax1LLNoInnerAdd", "testMax1LLNoInnerAdd2", "testMax1LLNoOuterAdd", "testMax1LLNoAdd",
|
|
"testMax2L", "testMax2R",
|
|
"testMax2LNoLeftAdd",
|
|
"testMax3",
|
|
"testMax4",
|
|
"testMin1",
|
|
"testMin2",
|
|
"testMin3",
|
|
"testMin4"})
|
|
public void runPositiveTests() {
|
|
int a = RunInfo.getRandom().nextInt();
|
|
int min = Integer.MIN_VALUE;
|
|
int max = Integer.MAX_VALUE;
|
|
|
|
assertPositiveResult(a);
|
|
assertPositiveResult(0);
|
|
assertPositiveResult(min);
|
|
assertPositiveResult(max);
|
|
}
|
|
|
|
@DontCompile
|
|
public void assertPositiveResult(int a) {
|
|
Asserts.assertEQ(Math.max(Math.max(((a >> 1) + 150), 200), ((a >> 1) + 100)), testMax1LL(a));
|
|
Asserts.assertEQ(testMax1LL(a) , testMax1LR(a));
|
|
Asserts.assertEQ(testMax1LL(a) , testMax1RL(a));
|
|
Asserts.assertEQ(testMax1LL(a) , testMax1RR(a));
|
|
Asserts.assertEQ(Math.max(Math.max((a >> 1), 200), (a >> 1) + 100) , testMax1LLNoInnerAdd(a));
|
|
Asserts.assertEQ(Math.max(Math.max((a >> 1), (a << 1)), (a >> 1) + 100) , testMax1LLNoInnerAdd2(a));
|
|
Asserts.assertEQ(Math.max(Math.max(((a >> 1) + 150), 200), a >> 1) , testMax1LLNoOuterAdd(a));
|
|
Asserts.assertEQ(Math.max(Math.max((a >> 1), 200), a >> 1) , testMax1LLNoAdd(a));
|
|
Asserts.assertEQ(Math.max(((a >> 1) + 10), ((a >> 1) + 11)) , testMax2L(a));
|
|
Asserts.assertEQ(testMax2L(a) , testMax2R(a));
|
|
Asserts.assertEQ(Math.max(a >> 1, ((a >> 1) + 11)) , testMax2LNoLeftAdd(a));
|
|
Asserts.assertEQ(Math.max(a, a) , testMax3(a));
|
|
Asserts.assertEQ(0 , testMax4(a));
|
|
|
|
Asserts.assertEQ(Math.min(((a >> 1) + 100), Math.min(((a >> 1) + 150), 200)), testMin1(a));
|
|
Asserts.assertEQ(Math.min(((a >> 1) + 10), ((a >> 1) + 11)) , testMin2(a));
|
|
Asserts.assertEQ(Math.min(a, a) , testMin3(a));
|
|
Asserts.assertEQ(0 , testMin4(a));
|
|
}
|
|
|
|
// The transformations in test*1 and test*2 can happen only if the compiler has enough information
|
|
// to determine that the two addition operations can not overflow.
|
|
|
|
// Transform max(x + c0, max(y + c1, z)) to max(add(x, c2), z) if x == y, where c2 = MAX2(c0, c1).
|
|
// c0,c1,c2 are constants. x,y,z can be any valid c2 nodes. In this example, x and y are
|
|
// RShiftI nodes and z is a ConI.
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1LL(int i) {
|
|
return Math.max(Math.max(((i >> 1) + 150), 200), ((i >> 1) + 100));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1LR(int i) {
|
|
return Math.max(Math.max(200, ((i >> 1) + 150)), ((i >> 1) + 100));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1RL(int i) {
|
|
return Math.max(((i >> 1) + 100), Math.max(((i >> 1) + 150), 200));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1RR(int i) {
|
|
return Math.max(((i >> 1) + 100), Math.max(200, ((i >> 1) + 150)));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1LLNoInnerAdd(int i) {
|
|
return Math.max(Math.max((i >> 1), 200), (i >> 1) + 100);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1LLNoInnerAdd2(int i) {
|
|
return Math.max(Math.max((i >> 1), (i << 1)), (i >> 1) + 100);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMax1LLNoOuterAdd(int i) {
|
|
return Math.max(Math.max(((i >> 1) + 150), 200), i >> 1);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.ADD})
|
|
@IR(counts = {IRNode.MAX_I, "1"})
|
|
public int testMax1LLNoAdd(int i) {
|
|
return Math.max(Math.max((i >> 1), 200), i >> 1);
|
|
}
|
|
|
|
// Similarly, transform min(x + c0, min(y + c1, z)) to min(add(x, c2), z) if x == y, where c2 = MIN2(c0, c1).
|
|
@Test
|
|
@IR(counts = {IRNode.MIN_I, "1",
|
|
IRNode.ADD , "1",
|
|
})
|
|
public int testMin1(int i) {
|
|
return Math.min(((i >> 1) + 100), Math.min(((i >> 1) + 150), 200));
|
|
}
|
|
|
|
// Transform max(x + c0, y + c1) to add(x, c2) if x == y, where c2 = MAX2(c0, c1).
|
|
// c0,c1,c2 are constants. x and y can be any valid c2 nodes. If they are equal, this
|
|
// transformation would take place. In this example, x and y are same RShiftI nodes.
|
|
@Test
|
|
@IR(failOn = {IRNode.MAX_I})
|
|
@IR(counts = {IRNode.ADD, "1"})
|
|
public int testMax2L(int i) {
|
|
return Math.max((i >> 1) + 10, (i >> 1) + 11);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.MAX_I})
|
|
@IR(counts = {IRNode.ADD, "1"})
|
|
public int testMax2R(int i) {
|
|
return Math.max((i >> 1) + 11, (i >> 1) + 10);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.MAX_I})
|
|
@IR(counts = {IRNode.ADD, "1"})
|
|
public int testMax2LNoLeftAdd(int i) {
|
|
return Math.max(i >> 1, (i >> 1) + 11);
|
|
}
|
|
|
|
// Similarly, transform min(x + c0, y + c1) to add(x, c2) if x == y, where c2 = MIN2(c0, c1).
|
|
@Test
|
|
@IR(failOn = {IRNode.MIN_I})
|
|
@IR(counts = {IRNode.ADD, "1"})
|
|
public int testMin2(int i) {
|
|
return Math.min((i >> 1) + 10, (i >> 1) + 11);
|
|
}
|
|
|
|
// Return the same node without generating a MaxINode/MinINode when a node is compared with itself.
|
|
// In this test, an integer is being compared with itself but it can be any valid c2 node.
|
|
@Test
|
|
@IR(failOn = {IRNode.MAX_I})
|
|
public int testMax3(int i) {
|
|
return Math.max(i, i);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.MIN_I})
|
|
public int testMin3(int i) {
|
|
return Math.min(i, i);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.MAX_I})
|
|
public int testMax4(int i) {
|
|
return Math.max(i, 0) < 0 ? 1 : 0;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.MIN_I})
|
|
public int testMin4(int i) {
|
|
return Math.min(i, 0) > 0 ? 1 : 0;
|
|
}
|
|
|
|
@Run(test = {"testTwoLevelsDifferentXY",
|
|
"testTwoLevelsNoLeftConstant",
|
|
"testTwoLevelsNoRightConstant",
|
|
"testDifferentXY",
|
|
"testNoLeftConstant",
|
|
"testNoRightConstant"})
|
|
public void runNegativeTests() {
|
|
int a = RunInfo.getRandom().nextInt();
|
|
int min = Integer.MIN_VALUE;
|
|
int max = Integer.MAX_VALUE;
|
|
|
|
assertNegativeResult(a);
|
|
assertNegativeResult(0);
|
|
assertNegativeResult(min);
|
|
assertNegativeResult(max);
|
|
|
|
testTwoLevelsDifferentXY(10);
|
|
testTwoLevelsNoLeftConstant(10, 42);
|
|
testTwoLevelsNoRightConstant(10, 42);
|
|
testDifferentXY(10);
|
|
testNoLeftConstant(10, 42);
|
|
testNoRightConstant(10, 42);
|
|
}
|
|
|
|
@DontCompile
|
|
public void assertNegativeResult(int a) {
|
|
Asserts.assertEQ(Math.max(Math.max(((a >> 1) + 150), 200), ((a >> 2) + 100)), testTwoLevelsDifferentXY(a));
|
|
Asserts.assertEQ(Math.max(Math.max(((a >> 1) + a*2), 200), ((a >> 1) + 100)), testTwoLevelsNoLeftConstant(a, a*2));
|
|
Asserts.assertEQ(Math.max(Math.max(((a >> 1) + 150), 200), ((a >> 1) + a*2)), testTwoLevelsNoRightConstant(a, a*2));
|
|
Asserts.assertEQ(Math.max((a >> 1) + 10, (a >> 2) + 11), testDifferentXY(a));
|
|
Asserts.assertEQ(Math.max((a >> 1) + a*2, (a >> 1) + 11), testNoLeftConstant(a, a*2));
|
|
Asserts.assertEQ(Math.max((a >> 1) + 10, (a >> 1) + a*2), testNoRightConstant(a, a*2));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "2"})
|
|
public int testTwoLevelsDifferentXY(int i) {
|
|
return Math.max(Math.max(((i >> 1) + 150), 200), ((i >> 2) + 100));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "2"})
|
|
public int testTwoLevelsNoLeftConstant(int i, int c0) {
|
|
return Math.max(Math.max(((i >> 1) + c0), 200), ((i >> 1) + 100));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "2"})
|
|
public int testTwoLevelsNoRightConstant(int i, int c1) {
|
|
return Math.max(Math.max(((i >> 1) + 150), 200), ((i >> 1) + c1));
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1"})
|
|
public int testDifferentXY(int i) {
|
|
return Math.max((i >> 1) + 10, (i >> 2) + 11);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1"})
|
|
public int testNoLeftConstant(int i, int c0) {
|
|
return Math.max((i >> 1) + c0, (i >> 1) + 11);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MAX_I, "1"})
|
|
public int testNoRightConstant(int i, int c1) {
|
|
return Math.max((i >> 1) + 10, (i >> 1) + c1);
|
|
}
|
|
|
|
|
|
}
|