Compiler Explorer

Source code

// Note: Must be built for a 32-bit target.

#[repr(align(0x2000_0000))]
#[allow(unused)]
struct Foo(u8);

pub fn main() {
    // Create 9 variables which collectively
    // take up more than the entire address
    // space.
    let v0 = Foo(0);
    let v1 = Foo(0);
    let v2 = Foo(0);
    let v3 = Foo(0);
    let v4 = Foo(0);
    let v5 = Foo(0);
    let v6 = Foo(0);
    let v7 = Foo(0);
    let v8 = Foo(0);

// Convert all to integers.
    let a0 = &v0 as *const _ as u32;
    let a1 = &v1 as *const _ as u32;
    let a2 = &v2 as *const _ as u32;
    let a3 = &v3 as *const _ as u32;
    let a4 = &v4 as *const _ as u32;
    let a5 = &v5 as *const _ as u32;
    let a6 = &v6 as *const _ as u32;
    let a7 = &v7 as *const _ as u32;
    let a8 = &v8 as *const _ as u32;

// All of these comparisons are optimized
    // away.
    if a0 & 0x1fff_ffff != 0 ||
       a1 & 0x1fff_ffff != 0 ||
       a2 & 0x1fff_ffff != 0 ||
       a3 & 0x1fff_ffff != 0 ||
       a4 & 0x1fff_ffff != 0 ||
       a5 & 0x1fff_ffff != 0 ||
       a6 & 0x1fff_ffff != 0 ||
       a7 & 0x1fff_ffff != 0 ||
       a8 & 0x1fff_ffff != 0 {
        panic!("not aligned");
    }

// So are these.
    if a0 == a1 ||
       a0 == a2 ||
       a1 == a2 ||
       a0 == a3 ||
       a1 == a3 ||
       a2 == a3 ||
       a0 == a4 ||
       a1 == a4 ||
       a2 == a4 ||
       a3 == a4 ||
       a0 == a5 ||
       a1 == a5 ||
       a2 == a5 ||
       a3 == a5 ||
       a4 == a5 ||
       a0 == a6 ||
       a1 == a6 ||
       a2 == a6 ||
       a3 == a6 ||
       a4 == a6 ||
       a5 == a6 ||
       a0 == a7 ||
       a1 == a7 ||
       a2 == a7 ||
       a3 == a7 ||
       a4 == a7 ||
       a5 == a7 ||
       a6 == a7 ||
       a0 == a8 ||
       a1 == a8 ||
       a2 == a8 ||
       a3 == a8 ||
       a4 == a8 ||
       a5 == a8 ||
       a6 == a8 ||
       a7 == a8 {
       panic!("overlapping");
    }

// Somehow we have 9 32-bit integers,
    // none of which are equal to each other,
    // but all of which are multiples of
    // 0x2000_0000.
}