Skip to content

revert test to check runtime evaluation instead of constant evaluation #30085

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Nov 28, 2015
Merged

revert test to check runtime evaluation instead of constant evaluation #30085

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
52 changes: 32 additions & 20 deletions src/test/run-pass/shift-near-oflo.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,39 +18,51 @@ fn main() {
test_right_shift();
}

pub static mut HACK: i32 = 0;

// Work around constant-evaluation
// The point of this test is to exercise the code generated for execution at runtime,
// `id` can never be flagged as a const fn by future aggressive analyses...
// due to the modification of the static
#[inline(never)]
fn id<T>(x: T) -> T {
unsafe { HACK += 1; }
x
}

fn test_left_shift() {
// negative rhs can panic, but values in [0,N-1] are okay for iN

macro_rules! tests {
($iN:ty, $uN:ty, $max_rhs:expr, $expect_i:expr, $expect_u:expr) => { {
let x = (1 as $iN) << 0;
let x = (1 as $iN) << id(0);
assert_eq!(x, 1);
let x = (1 as $uN) << 0;
let x = (1 as $uN) << id(0);
assert_eq!(x, 1);
let x = (1 as $iN) << $max_rhs;
let x = (1 as $iN) << id($max_rhs);
assert_eq!(x, $expect_i);
let x = (1 as $uN) << $max_rhs;
let x = (1 as $uN) << id($max_rhs);
assert_eq!(x, $expect_u);
// high-order bits on LHS are silently discarded without panic.
let x = (3 as $iN) << $max_rhs;
let x = (3 as $iN) << id($max_rhs);
assert_eq!(x, $expect_i);
let x = (3 as $uN) << $max_rhs;
let x = (3 as $uN) << id($max_rhs);
assert_eq!(x, $expect_u);
} }
}

let x = 1_i8 << 0;
let x = 1_i8 << id(0);
assert_eq!(x, 1);
let x = 1_u8 << 0;
let x = 1_u8 << id(0);
assert_eq!(x, 1);
let x = 1_i8 << 7;
let x = 1_i8 << id(7);
assert_eq!(x, std::i8::MIN);
let x = 1_u8 << 7;
let x = 1_u8 << id(7);
assert_eq!(x, 0x80);
// high-order bits on LHS are silently discarded without panic.
let x = 3_i8 << 7;
let x = 3_i8 << id(7);
assert_eq!(x, std::i8::MIN);
let x = 3_u8 << 7;
let x = 3_u8 << id(7);
assert_eq!(x, 0x80);

// above is (approximately) expanded from:
Expand All @@ -68,23 +80,23 @@ fn test_right_shift() {
($iN:ty, $uN:ty, $max_rhs:expr,
$signbit_i:expr, $highbit_i:expr, $highbit_u:expr) =>
{ {
let x = (1 as $iN) >> 0;
let x = (1 as $iN) >> id(0);
assert_eq!(x, 1);
let x = (1 as $uN) >> 0;
let x = (1 as $uN) >> id(0);
assert_eq!(x, 1);
let x = ($highbit_i) >> $max_rhs-1;
let x = ($highbit_i) >> id($max_rhs-1);
assert_eq!(x, 1);
let x = ($highbit_u) >> $max_rhs;
let x = ($highbit_u) >> id($max_rhs);
assert_eq!(x, 1);
// sign-bit is carried by arithmetic right shift
let x = ($signbit_i) >> $max_rhs;
let x = ($signbit_i) >> id($max_rhs);
assert_eq!(x, -1);
// low-order bits on LHS are silently discarded without panic.
let x = ($highbit_i + 1) >> $max_rhs-1;
let x = ($highbit_i + 1) >> id($max_rhs-1);
assert_eq!(x, 1);
let x = ($highbit_u + 1) >> $max_rhs;
let x = ($highbit_u + 1) >> id($max_rhs);
assert_eq!(x, 1);
let x = ($signbit_i + 1) >> $max_rhs;
let x = ($signbit_i + 1) >> id($max_rhs);
assert_eq!(x, -1);
} }
}
Expand Down