russell@unturf.com
0a580b313d
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
641 lines
23 KiB
Java
641 lines
23 KiB
Java
/*
|
|
* Copyright (c) 2021, 2025, Red Hat, 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.
|
|
*/
|
|
|
|
package compiler.c2.irTests;
|
|
|
|
import compiler.lib.ir_framework.*;
|
|
import jdk.test.lib.Utils;
|
|
import java.util.Random;
|
|
import java.util.Objects;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8277850 8278949 8285793 8346664
|
|
* @key randomness
|
|
* @summary C2: optimize mask checks in counted loops
|
|
* @library /test/lib /
|
|
* @run driver compiler.c2.irTests.TestShiftAndMask
|
|
*/
|
|
|
|
public class TestShiftAndMask {
|
|
private static final Random RANDOM = Utils.getRandomInstance();
|
|
|
|
public static void main(String[] args) {
|
|
TestFramework.run();
|
|
}
|
|
|
|
// any X << INT_MASK_WIDTH is zero under any INT_MASK
|
|
static final int INT_MASK_WIDTH = 1 + RANDOM.nextInt(30);
|
|
static final int INT_MAX_MASK = (1 << INT_MASK_WIDTH) - 1;
|
|
static final int INT_MASK = 1 + RANDOM.nextInt(INT_MAX_MASK);
|
|
static final int INT_MASK2 = 1 + RANDOM.nextInt(INT_MAX_MASK);
|
|
static final int INT_ZERO_CONST = RANDOM.nextInt() << INT_MASK_WIDTH;
|
|
|
|
static final int INT_RANDOM_CONST = RANDOM.nextInt();
|
|
static final int INT_RANDOM_SHIFT = RANDOM.nextInt();
|
|
static final int INT_RANDOM_MASK = RANDOM.nextInt();
|
|
|
|
// any X << LONG_MASK_WIDTH is zero under any LONG_MASK
|
|
static final int LONG_MASK_WIDTH = 1 + RANDOM.nextInt(62);
|
|
static final long LONG_MAX_MASK = (1L << LONG_MASK_WIDTH) - 1;
|
|
static final long LONG_MASK = 1 + RANDOM.nextLong(LONG_MAX_MASK);
|
|
static final long LONG_MASK2 = 1 + RANDOM.nextLong(LONG_MAX_MASK);
|
|
static final long LONG_ZERO_CONST = RANDOM.nextLong() << LONG_MASK_WIDTH;
|
|
|
|
static final long LONG_RANDOM_CONST = RANDOM.nextLong();
|
|
static final long LONG_RANDOM_SHIFT = RANDOM.nextLong();
|
|
static final long LONG_RANDOM_MASK = RANDOM.nextLong();
|
|
|
|
@Test
|
|
public static int intSumAndMask(int i, int j) {
|
|
return (j + i << INT_RANDOM_SHIFT + INT_RANDOM_CONST) & INT_RANDOM_MASK;
|
|
}
|
|
|
|
@Run(test = { "intSumAndMask" })
|
|
public static void checkIntSumAndMask() {
|
|
int j = RANDOM.nextInt();
|
|
int i = RANDOM.nextInt();
|
|
int res = intSumAndMask(i, j);
|
|
if (res != ((j + i << INT_RANDOM_SHIFT + INT_RANDOM_CONST) & INT_RANDOM_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = Argument.RANDOM_EACH)
|
|
@IR(failOn = { IRNode.AND_I, IRNode.LSHIFT_I })
|
|
public static int shiftMaskInt(int i) {
|
|
return (i << INT_MASK_WIDTH) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "shiftMaskInt")
|
|
public static void checkShiftMaskInt(int res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
public static long longSumAndMask(long i, long j) {
|
|
return (j + i << LONG_RANDOM_SHIFT + LONG_RANDOM_CONST) & LONG_RANDOM_MASK;
|
|
}
|
|
|
|
@Run(test = { "longSumAndMask" })
|
|
public static void checkLongSumAndMask() {
|
|
long j = RANDOM.nextLong();
|
|
long i = RANDOM.nextLong();
|
|
long res = longSumAndMask(i, j);
|
|
if (res != ((j + i << LONG_RANDOM_SHIFT + LONG_RANDOM_CONST) & LONG_RANDOM_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = Argument.RANDOM_EACH)
|
|
@IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_L })
|
|
public static long shiftMaskLong(long i) {
|
|
return (i << LONG_MASK_WIDTH) & LONG_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
|
|
@Check(test = "shiftMaskLong")
|
|
public static void checkShiftMaskLong(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
static volatile int barrier;
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.BOOLEAN_TOGGLE_FIRST_TRUE})
|
|
@IR(failOn = { IRNode.AND_I, IRNode.LSHIFT_I })
|
|
public static int shiftNonConstMaskInt(int i, boolean flag) {
|
|
int mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = INT_MASK;
|
|
} else {
|
|
mask = INT_MASK2;
|
|
}
|
|
return mask & (i << INT_MASK_WIDTH); // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "shiftNonConstMaskInt")
|
|
public static void checkShiftNonConstMaskInt(int res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.BOOLEAN_TOGGLE_FIRST_TRUE})
|
|
@IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_L })
|
|
public static long shiftNonConstMaskLong(long i, boolean flag) {
|
|
long mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = LONG_MASK;
|
|
} else {
|
|
mask = LONG_MASK2;
|
|
}
|
|
return mask & (i << LONG_MASK_WIDTH); // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "shiftNonConstMaskLong")
|
|
public static void checkShiftNonConstMaskLong(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I, IRNode.LSHIFT_I })
|
|
public static int addShiftMaskInt(int i, int j) {
|
|
return (j + (i << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskInt")
|
|
public static void addShiftMaskInt_runner() {
|
|
int i = RANDOM.nextInt();
|
|
int j = RANDOM.nextInt();
|
|
int res = addShiftMaskInt(i, j);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I, IRNode.LSHIFT_I })
|
|
public static int addShiftPlusConstMaskInt(int i, int j) {
|
|
return (j + ((i + INT_RANDOM_CONST) << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftPlusConstMaskInt")
|
|
public static void addShiftPlusConstMaskInt_runner() {
|
|
int i = RANDOM.nextInt();
|
|
int j = RANDOM.nextInt();
|
|
int res = addShiftPlusConstMaskInt(i, j);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.RANDOM_EACH})
|
|
@IR(counts = { IRNode.ADD_I, "2", IRNode.LSHIFT_I, "1" })
|
|
public static int addShiftPlusConstDisjointMaskInt(int i, int j) {
|
|
return (j + ((i + 5) << 2)) & 32; // NOT transformed even though (5<<2) & 32 == 0
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.RANDOM_EACH})
|
|
@IR(counts = { IRNode.ADD_I, "1", IRNode.LSHIFT_I, "1" })
|
|
public static int addShiftPlusConstOverlyLargeShift(int i, int j) {
|
|
return (j + i << 129) & 32; // NOT transformed, only lower 5 bits of shift count.
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I, IRNode.LSHIFT_I })
|
|
public static int addSshiftNonConstMaskInt(int i, int j, boolean flag) {
|
|
int mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = INT_MASK;
|
|
} else {
|
|
mask = INT_MASK2;
|
|
}
|
|
return mask & (j + (i << INT_MASK_WIDTH)); // transformed to: return j & mask;
|
|
}
|
|
|
|
@Run(test = "addSshiftNonConstMaskInt")
|
|
public static void addSshiftNonConstMaskInt_runner() {
|
|
int i = RANDOM.nextInt();
|
|
int j = RANDOM.nextInt();
|
|
int res = addSshiftNonConstMaskInt(i, j, true);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
res = addSshiftNonConstMaskInt(i, j, false);
|
|
if (res != (j & INT_MASK2)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I })
|
|
public static int addConstNonConstMaskInt(int j, boolean flag) {
|
|
int mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = INT_MASK;
|
|
} else {
|
|
mask = INT_MASK2;
|
|
}
|
|
return mask & (j + INT_ZERO_CONST); // transformed to: return j & mask;
|
|
}
|
|
|
|
@Run(test = "addConstNonConstMaskInt")
|
|
public static void addConstNonConstMaskInt_runner() {
|
|
int j = RANDOM.nextInt();
|
|
int res = addConstNonConstMaskInt(j, true);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
res = addConstNonConstMaskInt(j, false);
|
|
if (res != (j & INT_MASK2)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_L })
|
|
public static long addShiftMaskLong(long i, long j) {
|
|
return (j + (i << LONG_MASK_WIDTH)) & LONG_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskLong")
|
|
public static void addShiftMaskLong_runner() {
|
|
long i = RANDOM.nextLong();
|
|
long j = RANDOM.nextLong();
|
|
long res = addShiftMaskLong(i, j);
|
|
if (res != (j & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_L })
|
|
public static long addShiftPlusConstMaskLong(long i, long j) {
|
|
return (j + ((i + LONG_RANDOM_CONST) << LONG_MASK_WIDTH)) & LONG_MASK; // transformed to: return j & LONG_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftPlusConstMaskLong")
|
|
public static void addShiftPlusConstMaskLong_runner() {
|
|
long i = RANDOM.nextLong();
|
|
long j = RANDOM.nextLong();
|
|
long res = addShiftPlusConstMaskLong(i, j);
|
|
if (res != (j & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_L })
|
|
public static long addSshiftNonConstMaskLong(long i, long j, boolean flag) {
|
|
long mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = LONG_MASK;
|
|
} else {
|
|
mask = LONG_MASK2;
|
|
}
|
|
return mask & (j + (i << LONG_MASK_WIDTH)); // transformed to: return j & mask
|
|
}
|
|
|
|
@Run(test = "addSshiftNonConstMaskLong")
|
|
public static void addSshiftNonConstMaskLong_runner() {
|
|
long i = RANDOM.nextLong();
|
|
long j = RANDOM.nextLong();
|
|
long res = addSshiftNonConstMaskLong(i, j, true);
|
|
if (res != (j & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
res = addSshiftNonConstMaskLong(i, j, false);
|
|
if (res != (j & LONG_MASK2)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L })
|
|
public static long addConstNonConstMaskLong(long j, boolean flag) {
|
|
long mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = LONG_MASK;
|
|
} else {
|
|
mask = LONG_MASK2;
|
|
}
|
|
return mask & (j + LONG_ZERO_CONST); // transformed to: return j & mask;
|
|
}
|
|
|
|
@Run(test = "addConstNonConstMaskLong")
|
|
public static void addConstNonConstMaskLong_runner() {
|
|
long j = RANDOM.nextLong();
|
|
long res = addConstNonConstMaskLong(j, true);
|
|
if (res != (j & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
res = addConstNonConstMaskLong(j, false);
|
|
if (res != (j & LONG_MASK2)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.RANDOM_EACH})
|
|
@IR(failOn = { IRNode.AND_I, IRNode.ADD_I, IRNode.LSHIFT_I })
|
|
public static int addShiftMaskInt2(int i, int j) {
|
|
return ((j << INT_MASK_WIDTH) + (i << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "addShiftMaskInt2")
|
|
public static void checkAddShiftMaskInt2(int res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.RANDOM_EACH})
|
|
@IR(failOn = { IRNode.AND_L, IRNode.ADD_L, IRNode.LSHIFT_L })
|
|
public static long addShiftMaskLong2(long i, long j) {
|
|
return ((j << INT_MASK_WIDTH) + (i << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "addShiftMaskLong2")
|
|
public static void checkAddShiftMaskLong2(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
// Try to get add inputs swapped compared to other tests
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I, IRNode.LSHIFT_I })
|
|
public static int addShiftMaskInt3(int i, long j) {
|
|
int add1 = (i << INT_MASK_WIDTH);
|
|
int add2 = (int)j;
|
|
return (add1 + add2) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskInt3")
|
|
public static void addShiftMaskInt3_runner() {
|
|
int i = RANDOM.nextInt();
|
|
int j = RANDOM.nextInt();
|
|
int res = addShiftMaskInt3(i, j);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_L })
|
|
public static long addShiftMaskLong3(long i, float j) {
|
|
long add1 = (i << LONG_MASK_WIDTH);
|
|
long add2 = (long)j;
|
|
return (add1 + add2) & LONG_MASK; // transformed to: return j & LONG_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskLong3")
|
|
public static void addShiftMaskLong3_runner() {
|
|
long i = RANDOM.nextLong();
|
|
float j = RANDOM.nextFloat();
|
|
long res = addShiftMaskLong3(i, j);
|
|
if (res != (((long) j) & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH})
|
|
@IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_I, IRNode.CONV_I2L })
|
|
public static long shiftConvMask(int i) {
|
|
return ((long) (i << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "shiftConvMask")
|
|
public static void checkShiftConvMask(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.BOOLEAN_TOGGLE_FIRST_TRUE})
|
|
@IR(failOn = { IRNode.AND_L, IRNode.LSHIFT_I, IRNode.CONV_I2L })
|
|
public static long shiftNotConstConvMask(int i, boolean flag) {
|
|
long mask;
|
|
if (flag) {
|
|
barrier = 42;
|
|
mask = INT_MASK;
|
|
} else {
|
|
mask = INT_MASK2;
|
|
}
|
|
return mask & ((long) (i << INT_MASK_WIDTH)); // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "shiftNotConstConvMask")
|
|
public static void checkShiftNotConstConvMask(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.LSHIFT_I, IRNode.CONV_I2L })
|
|
public static long addShiftConvMask(int i, long j) {
|
|
return (j + (i << INT_MASK_WIDTH)) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftConvMask")
|
|
public static void addShiftConvMask_runner() {
|
|
int i = RANDOM.nextInt();
|
|
long j = RANDOM.nextLong();
|
|
long res = addShiftConvMask(i, j);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@Arguments(values = {Argument.RANDOM_EACH, Argument.RANDOM_EACH})
|
|
@IR(failOn = { IRNode.AND_L, IRNode.ADD_L, IRNode.LSHIFT_I, IRNode.CONV_I2L })
|
|
public static long addShiftConvMask2(int i, int j) {
|
|
return (((long) (j << INT_MASK_WIDTH)) + ((long) (i << INT_MASK_WIDTH))) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Check(test = "addShiftConvMask2")
|
|
public static void checkAddShiftConvMask2(long res) {
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_I })
|
|
public static int shiftMaskIntCheckIndex(int i, int length) {
|
|
return Objects.checkIndex(i << INT_MASK_WIDTH, length) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Run(test = "shiftMaskIntCheckIndex")
|
|
public static void shiftMaskIntCheckIndex_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
int res = shiftMaskIntCheckIndex(i, (i << INT_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_L })
|
|
public static long shiftMaskLongCheckIndex(long i, long length) {
|
|
return Objects.checkIndex(i << LONG_MASK_WIDTH, length) & LONG_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Run(test = "shiftMaskLongCheckIndex")
|
|
public static void shiftMaskLongCheckIndex_runner() {
|
|
long i = RANDOM.nextLong((Long.MAX_VALUE - 1) >> LONG_MASK_WIDTH);
|
|
long res = shiftMaskLongCheckIndex(i, (i << LONG_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_I, "1" })
|
|
@IR(failOn = { IRNode.ADD_I })
|
|
public static int addShiftMaskIntCheckIndex(int i, int j, int length) {
|
|
return (j + Objects.checkIndex(i << INT_MASK_WIDTH, length)) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskIntCheckIndex")
|
|
public static void addShiftMaskIntCheckIndex_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
int j = RANDOM.nextInt();
|
|
int res = addShiftMaskIntCheckIndex(i, j, (i << INT_MASK_WIDTH) + 1);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L })
|
|
public static long addShiftMaskLongCheckIndex(long i, long j, long length) {
|
|
return (j + Objects.checkIndex(i << LONG_MASK_WIDTH, length)) & LONG_MASK; // transformed to: return j & LONG_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskLongCheckIndex")
|
|
public static void addShiftMaskLongCheckIndex_runner() {
|
|
long i = RANDOM.nextLong((Long.MAX_VALUE - 1) >> LONG_MASK_WIDTH);
|
|
long j = RANDOM.nextLong();
|
|
long res = addShiftMaskLongCheckIndex(i, j, (i << LONG_MASK_WIDTH) + 1);
|
|
if (res != (j & LONG_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_I, IRNode.ADD_I })
|
|
public static int addShiftMaskIntCheckIndex2(int i, int j, int length) {
|
|
return (Objects.checkIndex(j << INT_MASK_WIDTH, length) + Objects.checkIndex(i << INT_MASK_WIDTH, length)) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
|
|
@Run(test = "addShiftMaskIntCheckIndex2")
|
|
public static void addShiftMaskIntCheckIndex2_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
int j = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
int res = addShiftMaskIntCheckIndex2(i, j, (Integer.max(i, j) << INT_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_L, IRNode.ADD_L })
|
|
public static long addShiftMaskLongCheckIndex2(long i, long j, long length) {
|
|
return (Objects.checkIndex(j << LONG_MASK_WIDTH, length) + Objects.checkIndex(i << LONG_MASK_WIDTH, length)) & LONG_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Run(test = "addShiftMaskLongCheckIndex2")
|
|
public static void addShiftMaskLongCheckIndex2_runner() {
|
|
long i = RANDOM.nextLong((Long.MAX_VALUE - 1) >> LONG_MASK_WIDTH);
|
|
long j = RANDOM.nextLong((Long.MAX_VALUE - 1) >> LONG_MASK_WIDTH);
|
|
long res = addShiftMaskLongCheckIndex2(i, j, (Long.max(i, j) << LONG_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_L, IRNode.CONV_I2L })
|
|
public static long shiftConvMaskCheckIndex(int i, int length) {
|
|
return ((long) Objects.checkIndex(i << INT_MASK_WIDTH, length)) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Run(test = "shiftConvMaskCheckIndex")
|
|
public static void shiftConvMaskCheckIndex_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
long res = shiftConvMaskCheckIndex(i, (i << INT_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(counts = { IRNode.AND_L, "1" })
|
|
@IR(failOn = { IRNode.ADD_L, IRNode.CONV_I2L })
|
|
public static long addShiftConvMaskCheckIndex(int i, long j, int length) {
|
|
return (j + Objects.checkIndex(i << INT_MASK_WIDTH, length)) & INT_MASK; // transformed to: return j & INT_MASK;
|
|
}
|
|
|
|
@Run(test = "addShiftConvMaskCheckIndex")
|
|
public static void addShiftConvMaskCheckIndex_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
long j = RANDOM.nextLong();
|
|
long res = addShiftConvMaskCheckIndex(i, j, (i << INT_MASK_WIDTH) + 1);
|
|
if (res != (j & INT_MASK)) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
|
|
@Test
|
|
@IR(failOn = { IRNode.AND_L, IRNode.ADD_L })
|
|
public static long addShiftConvMaskCheckIndex2(int i, int j, int length) {
|
|
return (((long) Objects.checkIndex(j << INT_MASK_WIDTH, length)) + ((long) Objects.checkIndex(i << INT_MASK_WIDTH, length))) & INT_MASK; // transformed to: return 0;
|
|
}
|
|
|
|
@Run(test = "addShiftConvMaskCheckIndex2")
|
|
public static void addShiftConvMaskCheckIndex2_runner() {
|
|
int i = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
int j = RANDOM.nextInt((Integer.MAX_VALUE - 1) >> INT_MASK_WIDTH);
|
|
long res = addShiftConvMaskCheckIndex2(i, j, (Integer.max(i, j) << INT_MASK_WIDTH) + 1);
|
|
if (res != 0) {
|
|
throw new RuntimeException("incorrect result: " + res);
|
|
}
|
|
}
|
|
}
|