/*
* Copyright 2010 Google, Inc. 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 6921969
* @summary Tests shorter long multiply sequences when the high 32 bits of long operands are known to be zero on x86_32
* @run main/othervm -Xbatch -XX:-Inline
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testNormal
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testLeftOptimized
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testRightOptimized
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testOptimized
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testLeftOptimized_LoadUI2L
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testRightOptimized_LoadUI2L
* -XX:CompileCommand=compileonly,compiler.c2.TestMultiplyLongHiZero::testOptimized_LoadUI2L
* compiler.c2.TestMultiplyLongHiZero
*/
package compiler.c2;
// This test must run without any command line arguments.
public class TestMultiplyLongHiZero {
private static void check(long leftFactor, long rightFactor, long optimizedProduct, long constantProduct) {
long normalProduct = leftFactor * rightFactor; // unaffected by the new optimization
if (optimizedProduct != constantProduct || normalProduct != constantProduct) {
throw new RuntimeException("Not all three products are equal: " +
Long.toHexString(normalProduct) + ", " +
Long.toHexString(optimizedProduct) + ", " +
Long.toHexString(constantProduct));
}
}
private static int initInt(String[] args, int v) {
if (args.length > 0) {
try {
return Integer.valueOf(args[0]);
} catch (NumberFormatException e) { }
}
return v;
}
private static final long mask32 = 0x00000000FFFFFFFFL;
private static void testNormal(int leftFactor, int rightFactor, long constantProduct) {
check((long) leftFactor,
(long) rightFactor,
(long) leftFactor * (long) rightFactor, // unaffected by the new optimization
constantProduct);
}
private static void testLeftOptimized(int leftFactor, int rightFactor, long constantProduct) {
check((leftFactor & mask32),
(long) rightFactor,
(leftFactor & mask32) * (long) rightFactor, // left factor optimized
constantProduct);
}
private static void testRightOptimized(int leftFactor, int rightFactor, long constantProduct) {
check((long) leftFactor,
(rightFactor & mask32),
(long) leftFactor * (rightFactor & mask32), // right factor optimized
constantProduct);
}
private static void testOptimized(int leftFactor, int rightFactor, long constantProduct) {
check((leftFactor & mask32),
(rightFactor & mask32),
(leftFactor & mask32) * (rightFactor & mask32), // both factors optimized
constantProduct);
}
private static void testLeftOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
check((leftFactor & mask32),
(long) rightFactor,
(factors[0] & mask32) * (long) rightFactor, // left factor optimized
constantProduct);
}
private static void testRightOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
check((long) leftFactor,
(rightFactor & mask32),
(long) leftFactor * (factors[1] & mask32), // right factor optimized
constantProduct);
}
private static void testOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
check((leftFactor & mask32),
(rightFactor & mask32),
(factors[0] & mask32) * (factors[1] & mask32), // both factors optimized
constantProduct);
}
private static void test(int leftFactor, int rightFactor,
long normalConstantProduct,
long leftOptimizedConstantProduct,
long rightOptimizedConstantProduct,
long optimizedConstantProduct) {
int[] factors = new int[2];
factors[0] = leftFactor;
factors[1] = rightFactor;
testNormal(leftFactor, rightFactor, normalConstantProduct);
testLeftOptimized(leftFactor, rightFactor, leftOptimizedConstantProduct);
testRightOptimized(leftFactor, rightFactor, rightOptimizedConstantProduct);
testOptimized(leftFactor, rightFactor, optimizedConstantProduct);
testLeftOptimized_LoadUI2L(leftFactor, rightFactor, leftOptimizedConstantProduct, factors);
testRightOptimized_LoadUI2L(leftFactor, rightFactor, rightOptimizedConstantProduct, factors);
testOptimized_LoadUI2L(leftFactor, rightFactor, optimizedConstantProduct, factors);
}
public static void main(String[] args) {
for (int i = 0; i < 100000; ++i) { // Trigger compilation
int i0 = initInt(args, 1);
int i1 = initInt(args, 3);
int i2 = initInt(args, -1);
int i3 = initInt(args, 0x7FFFFFFF);
test(i0, i1, 3L, 3L, 3L, 3L);
test(i0, i2, -1L, -1L, 0xFFFFFFFFL, 0xFFFFFFFFL);
test(i0, i3, 0x7FFFFFFFL, 0x7FFFFFFFL, 0x7FFFFFFFL, 0x7FFFFFFFL);
test(i1, i2, -3L, -3L, 0x2FFFFFFFDL, 0x2FFFFFFFDL);
test(i1, i3, 0x17FFFFFFDL, 0x17FFFFFFDL, 0x17FFFFFFDL, 0x17FFFFFFDL);
test(i2, i3, 0xFFFFFFFF80000001L, 0x7FFFFFFE80000001L,
0xFFFFFFFF80000001L, 0x7FFFFFFE80000001L);
}
}
}