212 lines
7.7 KiB
Java
212 lines
7.7 KiB
Java
/*
|
|
* Copyright (c) 2023, 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
|
|
* @summary Test intrinsic for divideUnsigned() and remainderUnsigned() methods for Long
|
|
* @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="riscv64" | os.arch=="aarch64"
|
|
* @library /test/lib /
|
|
* @run driver compiler.intrinsics.TestLongUnsignedDivMod
|
|
*/
|
|
|
|
package compiler.intrinsics;
|
|
import compiler.lib.ir_framework.*;
|
|
import java.math.*;
|
|
|
|
public class TestLongUnsignedDivMod {
|
|
private int BUFFER_SIZE;
|
|
private long[] dividends;
|
|
private long[] divisors;
|
|
private long[] quotients;
|
|
private long[] remainders;
|
|
long TWO_31 = 1L << Integer.SIZE - 1;
|
|
long TWO_32 = 1L << Integer.SIZE;
|
|
long TWO_33 = 1L << Integer.SIZE + 1;
|
|
BigInteger NINETEEN = BigInteger.valueOf(19L);
|
|
BigInteger TWO_63 = BigInteger.ONE.shiftLeft(Long.SIZE - 1);
|
|
BigInteger TWO_64 = BigInteger.ONE.shiftLeft(Long.SIZE);
|
|
BigInteger[] inRange = {
|
|
BigInteger.ZERO,
|
|
BigInteger.ONE,
|
|
BigInteger.TEN,
|
|
NINETEEN,
|
|
|
|
BigInteger.valueOf(TWO_31 - 19L),
|
|
BigInteger.valueOf(TWO_31 - 10L),
|
|
BigInteger.valueOf(TWO_31 - 1L),
|
|
BigInteger.valueOf(TWO_31),
|
|
BigInteger.valueOf(TWO_31 + 1L),
|
|
BigInteger.valueOf(TWO_31 + 10L),
|
|
BigInteger.valueOf(TWO_31 + 19L),
|
|
|
|
BigInteger.valueOf(TWO_32 - 19L),
|
|
BigInteger.valueOf(TWO_32 - 10L),
|
|
BigInteger.valueOf(TWO_32 - 1L),
|
|
BigInteger.valueOf(TWO_32),
|
|
BigInteger.valueOf(TWO_32 + 1L),
|
|
BigInteger.valueOf(TWO_32 + 10L),
|
|
BigInteger.valueOf(TWO_32 - 19L),
|
|
|
|
BigInteger.valueOf(TWO_33 - 19L),
|
|
BigInteger.valueOf(TWO_33 - 10L),
|
|
BigInteger.valueOf(TWO_33 - 1L),
|
|
BigInteger.valueOf(TWO_33),
|
|
BigInteger.valueOf(TWO_33 + 1L),
|
|
BigInteger.valueOf(TWO_33 + 10L),
|
|
BigInteger.valueOf(TWO_33 + 19L),
|
|
|
|
TWO_63.subtract(NINETEEN),
|
|
TWO_63.subtract(BigInteger.TEN),
|
|
TWO_63.subtract(BigInteger.ONE),
|
|
TWO_63,
|
|
TWO_63.add(BigInteger.ONE),
|
|
TWO_63.add(BigInteger.TEN),
|
|
TWO_63.add(NINETEEN),
|
|
|
|
TWO_64.subtract(NINETEEN),
|
|
TWO_64.subtract(BigInteger.TEN),
|
|
TWO_64.subtract(BigInteger.ONE),
|
|
};
|
|
|
|
public static void main(String args[]) {
|
|
TestFramework.run(TestLongUnsignedDivMod.class);
|
|
}
|
|
|
|
public TestLongUnsignedDivMod() {
|
|
BUFFER_SIZE = inRange.length * inRange.length;
|
|
dividends = new long[BUFFER_SIZE];
|
|
divisors = new long[BUFFER_SIZE];
|
|
quotients = new long[BUFFER_SIZE];
|
|
remainders = new long[BUFFER_SIZE];
|
|
|
|
int idx = 0;
|
|
for (int i = 0; i < inRange.length; i++) {
|
|
for (int j = 0; j < inRange.length; j++){
|
|
dividends[idx] = inRange[i].longValue();
|
|
divisors[idx] = inRange[j].longValue();
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Test // needs to be run in (fast) debug mode
|
|
@Warmup(10000)
|
|
@IR(counts = {IRNode.UDIV_L, ">= 1"}) // At least one UDivL node is generated if intrinsic is used
|
|
public void testDivideUnsigned() {
|
|
for (int i = 0; i < BUFFER_SIZE; i++) {
|
|
try {
|
|
quotients[i] = Long.divideUnsigned(dividends[i], divisors[i]);
|
|
} catch(ArithmeticException ea) {
|
|
; // expected
|
|
}
|
|
}
|
|
checkResult("divideUnsigned");
|
|
}
|
|
|
|
@Test // needs to be run in (fast) debug mode
|
|
@Warmup(10000)
|
|
@IR(counts = {IRNode.UMOD_L, ">= 1"}) // At least one UModL node is generated if intrinsic is used
|
|
public void testRemainderUnsigned() {
|
|
for (int i = 0; i < BUFFER_SIZE; i++) {
|
|
try {
|
|
remainders[i] = Long.remainderUnsigned(dividends[i], divisors[i]);
|
|
} catch(ArithmeticException ea) {
|
|
; // expected
|
|
}
|
|
}
|
|
checkResult("remainderUnsigned");
|
|
}
|
|
|
|
|
|
@Test // needs to be run in (fast) debug mode
|
|
@Warmup(10000)
|
|
@IR(applyIfPlatform = {"x64", "true"},
|
|
counts = {IRNode.UDIV_MOD_L, ">= 1"}) // At least one UDivModL node is generated if intrinsic is used
|
|
public void testDivModUnsigned() {
|
|
for (int i = 0; i < BUFFER_SIZE; i++) {
|
|
try {
|
|
divmod(dividends[i], divisors[i], i);
|
|
} catch(ArithmeticException ea) {
|
|
; // expected
|
|
}
|
|
}
|
|
checkResult("divmodUnsigned");
|
|
}
|
|
|
|
private void divmod(long dividend, long divisor, int i) {
|
|
quotients[i] = Long.divideUnsigned(dividend, divisor);
|
|
remainders[i] = Long.remainderUnsigned(dividend, divisor);
|
|
}
|
|
|
|
public void checkResult(String mode) {
|
|
for (int i=0; i < BUFFER_SIZE; i++) {
|
|
if (divisors[i] == 0) continue;
|
|
BigInteger dividend = toUnsignedBigInteger(dividends[i]);
|
|
BigInteger divisor = toUnsignedBigInteger(divisors[i]);
|
|
|
|
long quo = dividend.divide(divisor).longValue();
|
|
long rem = dividend.remainder(divisor).longValue();
|
|
boolean mismatch;
|
|
switch (mode) {
|
|
case "divideUnsigned": mismatch = (quotients[i] != quo); break;
|
|
case "remainderUnsigned": mismatch = (remainders[i] != rem); break;
|
|
case "divmodUnsigned": mismatch = (quotients[i] != quo || remainders[i] != rem); break;
|
|
default: throw new IllegalArgumentException("incorrect mode");
|
|
}
|
|
if (mismatch) {
|
|
throw new RuntimeException(errorMessage(mode, i, quo, rem));
|
|
}
|
|
}
|
|
}
|
|
|
|
private String errorMessage(String mode, int i, long quo, long rem) {
|
|
StringBuilder sb = new StringBuilder(mode);
|
|
sb = sb.append(" test error at index=").append(i);
|
|
sb = sb.append(": dividend=").append(dividends[i]);
|
|
sb = sb.append("; divisor= ").append(divisors[i]);
|
|
if (!mode.equals("remainderUnsigned")) {
|
|
sb = sb.append("; quotient (expected)= ").append(quo);
|
|
sb = sb.append("; quotient (actual)= ").append(quotients[i]);
|
|
}
|
|
if (!mode.equals("divideUnsigned")) {
|
|
sb = sb.append("; remainder (expected)= ").append(rem);
|
|
sb = sb.append("; remainder (actual)= ").append(remainders[i]);
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private BigInteger toUnsignedBigInteger(long i) {
|
|
if (i >= 0L)
|
|
return BigInteger.valueOf(i);
|
|
else {
|
|
int upper = (int) (i >>> 32);
|
|
int lower = (int) i;
|
|
|
|
// return (upper << 32) + lower
|
|
return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
|
|
add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
|
|
}
|
|
}
|
|
|
|
}
|