206 lines
7.2 KiB
Java
206 lines
7.2 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
package compiler.c2.irTests;
|
|
|
|
import jdk.test.lib.Asserts;
|
|
import compiler.lib.ir_framework.*;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8267265
|
|
* @summary Test that Ideal transformations of DivINode* are being performed as expected.
|
|
* @library /test/lib /
|
|
* @run driver compiler.c2.irTests.DivINodeIdealizationTests
|
|
*/
|
|
public class DivINodeIdealizationTests {
|
|
public static void main(String[] args) {
|
|
TestFramework.run();
|
|
}
|
|
|
|
@Run(test = {"constant", "identity", "identityAgain", "identityThird",
|
|
"retainDenominator", "divByNegOne", "divByPow2And",
|
|
"divByPow2And1", "divByPow2", "divByNegPow2",
|
|
"magicDiv"})
|
|
public void runMethod() {
|
|
int a = RunInfo.getRandom().nextInt();
|
|
a = (a == 0) ? 1 : a;
|
|
int b = RunInfo.getRandom().nextInt();
|
|
b = (b == 0) ? 1 : b;
|
|
|
|
int min = Integer.MIN_VALUE;
|
|
int max = Integer.MAX_VALUE;
|
|
|
|
assertResult(0, 0, true);
|
|
assertResult(a, b, false);
|
|
assertResult(min, min, false);
|
|
assertResult(max, max, false);
|
|
}
|
|
|
|
@DontCompile
|
|
public void assertResult(int a, int b, boolean shouldThrow) {
|
|
try {
|
|
Asserts.assertEQ(a / a, constant(a));
|
|
Asserts.assertFalse(shouldThrow, "Expected an exception to be thrown.");
|
|
}
|
|
catch (ArithmeticException e) {
|
|
Asserts.assertTrue(shouldThrow, "Did not expected an exception to be thrown.");
|
|
}
|
|
|
|
try {
|
|
Asserts.assertEQ(a / (b / b), identityThird(a, b));
|
|
Asserts.assertFalse(shouldThrow, "Expected an exception to be thrown.");
|
|
}
|
|
catch (ArithmeticException e) {
|
|
Asserts.assertTrue(shouldThrow, "Did not expected an exception to be thrown.");
|
|
}
|
|
|
|
try {
|
|
Asserts.assertEQ((a * b) / b, retainDenominator(a, b));
|
|
Asserts.assertFalse(shouldThrow, "Expected an exception to be thrown.");
|
|
}
|
|
catch (ArithmeticException e) {
|
|
Asserts.assertTrue(shouldThrow, "Did not expected an exception to be thrown.");
|
|
}
|
|
|
|
Asserts.assertEQ(a / 1 , identity(a));
|
|
Asserts.assertEQ(a / (13 / 13), identityAgain(a));
|
|
Asserts.assertEQ(a / -1 , divByNegOne(a));
|
|
Asserts.assertEQ((a & -4) / 2 , divByPow2And(a));
|
|
Asserts.assertEQ((a & -2) / 2 , divByPow2And1(a));
|
|
Asserts.assertEQ(a / 8 , divByPow2(a));
|
|
Asserts.assertEQ(a / -8 , divByNegPow2(a));
|
|
Asserts.assertEQ(a / 13 , magicDiv(a));
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.DIV_BY_ZERO_TRAP, "1"})
|
|
// Checks x / x => 1
|
|
public int constant(int x) {
|
|
return x / x;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
// Checks x / 1 => x
|
|
public int identity(int x) {
|
|
return x / 1;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
// Checks x / (c / c) => x
|
|
public int identityAgain(int x) {
|
|
return x / (13 / 13);
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.DIV_BY_ZERO_TRAP, "1"})
|
|
// Checks x / (y / y) => x
|
|
public int identityThird(int x, int y) {
|
|
return x / (y / y);
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = {IRNode.MUL, "1",
|
|
IRNode.DIV, "1",
|
|
IRNode.DIV_BY_ZERO_TRAP, "1"
|
|
})
|
|
// Hotspot should keep the division because it may cause a division by zero trap
|
|
public int retainDenominator(int x, int y) {
|
|
return (x * y) / y;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.SUB_I, "1"})
|
|
// Checks x / -1 => 0 - x
|
|
public int divByNegOne(int x) {
|
|
return x / -1;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.AND, "1",
|
|
IRNode.RSHIFT, "1",
|
|
})
|
|
// Checks (x & -(2^c0)) / 2^c1 => (x >> c1) & (2^c0 >> c1) => (x >> c1) & c3 where 2^c0 > |2^c1| "AND" c3 = 2^c0 >> c1
|
|
// Having a large enough and in the dividend removes the need to account for rounding when converting to shifts and multiplies as in divByPow2()
|
|
public int divByPow2And(int x) {
|
|
return (x & -4) / 2;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV, IRNode.AND})
|
|
@IR(counts = {IRNode.RSHIFT, "1"})
|
|
// Checks (x & -(2^c0)) / 2^c0 => x >> c0
|
|
// If the negative of the constant within the & equals the divisor then the and can be removed as it only affects bits that will be shifted off
|
|
public int divByPow2And1(int x) {
|
|
return (x & -2) / 2;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.URSHIFT, "1",
|
|
IRNode.RSHIFT, "2",
|
|
IRNode.ADD_I, "1",
|
|
})
|
|
// Checks x / 2^c0 => x + ((x >> (32-1)) >>> (32 - c0)) >> c0 => x + ((x >> 31) >>> c1) >> c0 where c1 = 32 - c0
|
|
// An additional (dividend - 1) needs to be added to the shift to account for rounding when dealing with negative numbers.
|
|
// Since x may be negative in this method, an additional add, logical right shift, and signed shift are needed to account for rounding.
|
|
public int divByPow2(int x) {
|
|
return x / 8;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.URSHIFT, "1",
|
|
IRNode.RSHIFT, "2",
|
|
IRNode.ADD_I, "1",
|
|
IRNode.SUB_I, "1",
|
|
})
|
|
// Checks x / -(2^c0) =>0 - (x + ((x >> (32-1)) >>> (32 - c0)) >> c0) => 0 - (x + ((x >> 31) >>> c1) >> c0) where c1 = 32 - c0
|
|
// Similar to divByPow2() except a negative divisor turns positive.
|
|
// After the transformations, 0 is subtracted by the whole expression
|
|
// to account for the negative.
|
|
public int divByNegPow2(int x) {
|
|
return x / -8;
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = {IRNode.DIV})
|
|
@IR(counts = {IRNode.SUB, "1",
|
|
IRNode.MUL, "1",
|
|
IRNode.CONV_I2L, "1",
|
|
IRNode.CONV_L2I, "1",
|
|
})
|
|
// Checks magic int division occurs in general when dividing by a non power of 2.
|
|
// More tests can be made to cover the specific cases for differences in the
|
|
// graph that depend upon different values for the "magic constant" and the
|
|
// "shift constant"
|
|
public int magicDiv(int x) {
|
|
return x / 13;
|
|
}
|
|
}
|