blob: 4bda31fda52e47b422842c6b312347b5fa168ae0 [file] [log] [blame]
// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// @dart = 2.9
// VMOptions=--optimization-counter-threshold=10 --no-background-compilation
// VMOptions=--optimization-counter-threshold=10 --no-background-compilation --use_slow_path
// Test for special cases of << and >> integer operations with int64.
import "package:expect/expect.dart";
// int64 value, does not fit to smi
int v1 = 0x778899aabbccddee;
int v2 = 0x6000000000000000;
int v3 = -0x778899aabbccddee;
int negativeInt64 = -0x7000000000000000;
int smi = 128;
int negativeSmi = -3;
int shl(int a, int b) => a << b;
int shr(int a, int b) => a >> b;
int shlUint32(int a, int b) => ((a & 0xffff) << b) & 0xffff;
int shrUint32(int a, int b) => (a & 0xffff) >> b;
int testInt64ShlByNegative1(int a, int b) {
int x = a + 1;
int y = a - 2;
try {
x = a << b;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShlByNegative2(int a, int b) {
int x = a + 1;
int y = a - 2;
try {
x = shl(a, b);
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShlByNegative3(int a) {
int x = a + 1;
int y = a - 2;
try {
int i = -64;
x = a << i;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShrByNegative1(int a, int b) {
int x = a + 1;
int y = a - 2;
try {
x = a >> b;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShrByNegative2(int a, int b) {
int x = a + 1;
int y = a - 2;
try {
x = shr(a, b);
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShrByNegative3(int a) {
int x = a + 1;
int y = a - 2;
try {
int i = -64;
x = a >> i;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0x778899aabbccddef, x);
Expect.equals(0x778899aabbccddec, y);
}
}
int testInt64ShlByLarge1(int a, int b) {
int x = a << b;
Expect.equals(0, x);
}
int testInt64ShlByLarge2(int a) {
int i = 64;
int x = a << i;
Expect.equals(0, x);
}
int testInt64ShlByLarge3(int a) {
int i = 0x7fffffffffffffff;
int x = a << i;
Expect.equals(0, x);
}
int testInt64ShrByLarge1a(int a, int b) {
int x = a >> b;
Expect.equals(0, x);
}
int testInt64ShrByLarge1b(int a, int b) {
int x = a >> b;
Expect.equals(-1, x);
}
int testInt64ShrByLarge2a(int a) {
int i = 64;
int x = a >> i;
Expect.equals(0, x);
}
int testInt64ShrByLarge2b(int a) {
int i = 64;
int x = a >> i;
Expect.equals(-1, x);
}
int testInt64ShrByLarge3a(int a) {
int i = 0x7fffffffffffffff;
int x = a >> i;
Expect.equals(0, x);
}
int testInt64ShrByLarge3b(int a) {
int i = 0x7fffffffffffffff;
int x = a >> i;
Expect.equals(-1, x);
}
int testUint32ShlByNegative1(int a, int b) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
x = ((a & 0xffff) << b) & 0xffff;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
return x;
}
int testUint32ShlByNegative2(int a, int b) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
x = shlUint32(a, b);
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
}
int testUint32ShlByNegative3(int a) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
int i = -64;
x = ((a & 0xffff) << i) & 0xffff;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
}
int testUint32ShrByNegative1(int a, int b) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
x = ((a & 0xffff) >> b) & 0xffff;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
}
int testUint32ShrByNegative2(int a, int b) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
x = shrUint32(a, b);
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
}
int testUint32ShrByNegative3(int a) {
int x = (a & 0xfff) + 1;
int y = (a & 0xfff) - 2;
try {
int i = -64;
x = ((a & 0xffff) >> i) & 0xffff;
Expect.fail('Shift by negative count should throw an error');
} on ArgumentError {
Expect.equals(0xdef, x);
Expect.equals(0xdec, y);
}
}
int testUint32ShlByLarge1(int a, int b) {
int x = ((a & 0xffff) << b) & 0xffff;
Expect.equals(0, x);
}
int testUint32ShlByLarge2(int a) {
int i = 64;
int x = ((a & 0xffff) << i) & 0xffff;
Expect.equals(0, x);
}
int testUint32ShlByLarge3(int a) {
int i = 0x7fffffffffffffff;
int x = ((a & 0xffff) << i) & 0xffff;
Expect.equals(0, x);
}
int testUint32ShrByLarge1(int a, int b) {
int x = ((a & 0xffff) >> b) & 0xffff;
Expect.equals(0, x);
}
int testUint32ShrByLarge2(int a) {
int i = 64;
int x = ((a & 0xffff) >> i) & 0xffff;
Expect.equals(0, x);
}
int testUint32ShrByLarge3(int a) {
int i = 0x7fffffffffffffff;
int x = ((a & 0xffff) >> i) & 0xffff;
Expect.equals(0, x);
}
doTests1() {
testInt64ShlByNegative1(v1, negativeSmi);
testInt64ShlByNegative2(v1, negativeSmi);
testInt64ShlByNegative3(v1);
testInt64ShrByNegative1(v1, negativeSmi);
testInt64ShrByNegative2(v1, negativeSmi);
testInt64ShrByNegative3(v1);
testInt64ShlByLarge1(v1, smi);
testInt64ShlByLarge1(v3, smi);
testInt64ShlByLarge2(v1);
testInt64ShlByLarge2(v3);
testInt64ShlByLarge3(v1);
testInt64ShlByLarge3(v3);
testInt64ShrByLarge1a(v1, smi);
testInt64ShrByLarge1b(v3, smi);
testInt64ShrByLarge2a(v1);
testInt64ShrByLarge2b(v3);
testInt64ShrByLarge3a(v1);
testInt64ShrByLarge3b(v3);
testUint32ShlByNegative1(v1, negativeSmi);
testUint32ShlByNegative2(v1, negativeSmi);
testUint32ShlByNegative3(v1);
testUint32ShrByNegative1(v1, negativeSmi);
testUint32ShrByNegative2(v1, negativeSmi);
testUint32ShrByNegative3(v1);
testUint32ShlByLarge1(v1, smi);
testUint32ShlByLarge1(v3, smi);
testUint32ShlByLarge2(v1);
testUint32ShlByLarge2(v3);
testUint32ShlByLarge3(v1);
testUint32ShlByLarge3(v3);
testUint32ShrByLarge1(v1, smi);
testUint32ShrByLarge1(v3, smi);
testUint32ShrByLarge2(v1);
testUint32ShrByLarge2(v3);
testUint32ShrByLarge3(v1);
testUint32ShrByLarge3(v3);
}
doTests2() {
testInt64ShlByNegative1(v1, negativeInt64);
testInt64ShlByNegative2(v1, negativeInt64);
testInt64ShrByNegative1(v1, negativeInt64);
testInt64ShrByNegative2(v1, negativeInt64);
testInt64ShlByLarge1(v1, v2);
testInt64ShlByLarge1(v3, v2);
testInt64ShrByLarge1a(v1, v2);
testInt64ShrByLarge1b(v3, v2);
testUint32ShlByNegative1(v1, negativeInt64);
testUint32ShlByNegative2(v1, negativeInt64);
testUint32ShrByNegative1(v1, negativeInt64);
testUint32ShrByNegative2(v1, negativeInt64);
testUint32ShlByLarge1(v1, v2);
testUint32ShlByLarge1(v3, v2);
testUint32ShrByLarge1(v1, v2);
testUint32ShrByLarge1(v3, v2);
}
main() {
for (var i = 0; i < 20; ++i) {
doTests1();
}
for (var i = 0; i < 50; ++i) {
doTests2();
}
}