overflowing left shift can lead to pseudo-byte with hidden bits

[pnkfelix]

Here is some strange code uncovered by a test I wrote for #23536:

fn id<T>(x: T) -> T { x }

fn main() {
    let spot: Option<i8>;
    let x = 1_i8 << id(8_i8);
    spot = Some(x);
    assert_eq!(spot.unwrap(), 0);
    println!("so we stored a zero byte ... but:");
    assert_eq!(x, 0);
}

Even in the playpen, this prints:

so we stored a zero byte ... but:
thread '<main>' panicked at 'assertion failed: `(left == right) && (right == left)` (left: `0`, right: `0`)', <anon>:9
playpen: application terminated with error code 101

Note those "crazy, non-matching" left and right values.

(Presumably something with LLVM's low-level code is leaving x in a register, thus yielding hidden high-order bits after the shift is done; those need to be masked away before we attempt to compare with another register.)

[pnkfelix]

Ah, this may be hitting an Undefined Behavior scenario in LLVM ... in particular, doing this instead:

    let x = 2_i8 << id(7_i8);

does not seem to yield the same bug.

[pnkfelix]

okay so this is probably a duplicate of #10183. It is just surprising because it implies that the limit on shift operations is not just 32 or 64 bits, but in fact can be as little as 8 bits (i.e. for an i8/u8).

[pnkfelix]

closing as duplicate as #10183

[nikomatsakis]

@pnkfelix indeed the limit is the number of bits in the value being shifted, and I agree this is a dup