Manual adjustments

dtolnay · dtolnay · commit 274085cebdbb · 2022-06-21T23:52:24.000-07:00
diff --git a/tests/fail/unaligned_pointers/dyn_alignment.rs b/tests/fail/unaligned_pointers/dyn_alignment.rs
@@ -6,8 +6,8 @@
 struct MuchAlign;
 
 fn main() {
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let buf = [0u32; 256];
         // `buf` is sufficiently aligned for `layout.align` on a `dyn Debug`, but not
         // for the actual alignment required by `MuchAlign`.
diff --git a/tests/fail/unaligned_pointers/reference_to_packed.rs b/tests/fail/unaligned_pointers/reference_to_packed.rs
@@ -10,8 +10,8 @@ struct Foo {
 }
 
 fn main() {
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let foo = Foo { x: 42, y: 99 };
         let p = &foo.x;
         let i = *p; //~ERROR alignment 4 is required
diff --git a/tests/fail/unaligned_pointers/unaligned_ptr1.rs b/tests/fail/unaligned_pointers/unaligned_ptr1.rs
@@ -2,8 +2,8 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const u32;
         // This must fail because alignment is violated: the allocation's base is not sufficiently aligned.
diff --git a/tests/fail/unaligned_pointers/unaligned_ptr3.rs b/tests/fail/unaligned_pointers/unaligned_ptr3.rs
@@ -2,8 +2,8 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let x = [2u16, 3, 4, 5]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const *const u8; // cast to ptr-to-ptr, so that we load a ptr
         // This must fail because alignment is violated. Test specifically for loading pointers,
diff --git a/tests/fail/unaligned_pointers/unaligned_ptr4.rs b/tests/fail/unaligned_pointers/unaligned_ptr4.rs
@@ -4,8 +4,9 @@
 fn main() {
     // Make sure we notice when a u16 is loaded at offset 1 into a u8 allocation.
     // (This would be missed if u8 allocations are *always* at odd addresses.)
+    //
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let x = [0u8; 4];
         let ptr = x.as_ptr().wrapping_offset(1).cast::<u16>();
         let _val = unsafe { *ptr }; //~ERROR but alignment
diff --git a/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs b/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs
@@ -3,8 +3,8 @@
 use std::ptr;
 
 fn main() {
+    // Try many times as this might work by chance.
     for _ in 0..10 {
-        // Try many times as this might work by chance.
         let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
         let x = &x[0] as *const _ as *const u32;
         // This must fail because alignment is violated: the allocation's base is not sufficiently aligned.
diff --git a/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs b/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs
@@ -3,8 +3,8 @@
 // compile-flags: -Zmir-opt-level=0 -Zmiri-disable-validation
 
 fn main() {
+    // Try many times as this might work by chance.
     for i in 0..10 {
-        // Try many times as this might work by chance.
         let x = i as u8;
         let x = &x as *const _ as *const [u32; 0];
         // This must fail because alignment is violated. Test specifically for loading ZST.
diff --git a/tests/pass/intrinsics-integer.rs b/tests/pass/intrinsics-integer.rs
@@ -13,194 +13,110 @@ use std::intrinsics::*;
 
 pub fn main() {
     unsafe {
-        assert_eq!(ctpop(0u8), 0);
-        assert_eq!(ctpop(0i8), 0);
-        assert_eq!(ctpop(0u16), 0);
-        assert_eq!(ctpop(0i16), 0);
-        assert_eq!(ctpop(0u32), 0);
-        assert_eq!(ctpop(0i32), 0);
-        assert_eq!(ctpop(0u64), 0);
-        assert_eq!(ctpop(0i64), 0);
-
-        assert_eq!(ctpop(1u8), 1);
-        assert_eq!(ctpop(1i8), 1);
-        assert_eq!(ctpop(1u16), 1);
-        assert_eq!(ctpop(1i16), 1);
-        assert_eq!(ctpop(1u32), 1);
-        assert_eq!(ctpop(1i32), 1);
-        assert_eq!(ctpop(1u64), 1);
-        assert_eq!(ctpop(1i64), 1);
-
-        assert_eq!(ctpop(10u8), 2);
-        assert_eq!(ctpop(10i8), 2);
-        assert_eq!(ctpop(10u16), 2);
-        assert_eq!(ctpop(10i16), 2);
-        assert_eq!(ctpop(10u32), 2);
-        assert_eq!(ctpop(10i32), 2);
-        assert_eq!(ctpop(10u64), 2);
-        assert_eq!(ctpop(10i64), 2);
-
-        assert_eq!(ctpop(100u8), 3);
-        assert_eq!(ctpop(100i8), 3);
-        assert_eq!(ctpop(100u16), 3);
-        assert_eq!(ctpop(100i16), 3);
-        assert_eq!(ctpop(100u32), 3);
-        assert_eq!(ctpop(100i32), 3);
-        assert_eq!(ctpop(100u64), 3);
-        assert_eq!(ctpop(100i64), 3);
-
-        assert_eq!(ctpop(-1i8 as u8), 8);
-        assert_eq!(ctpop(-1i8), 8);
-        assert_eq!(ctpop(-1i16 as u16), 16);
-        assert_eq!(ctpop(-1i16), 16);
-        assert_eq!(ctpop(-1i32 as u32), 32);
-        assert_eq!(ctpop(-1i32), 32);
-        assert_eq!(ctpop(-1i64 as u64), 64);
-        assert_eq!(ctpop(-1i64), 64);
-
-        assert_eq!(ctlz(0u8), 8);
-        assert_eq!(ctlz(0i8), 8);
-        assert_eq!(ctlz(0u16), 16);
-        assert_eq!(ctlz(0i16), 16);
-        assert_eq!(ctlz(0u32), 32);
-        assert_eq!(ctlz(0i32), 32);
-        assert_eq!(ctlz(0u64), 64);
-        assert_eq!(ctlz(0i64), 64);
-
-        assert_eq!(ctlz(1u8), 7);
-        assert_eq!(ctlz(1i8), 7);
-        assert_eq!(ctlz(1u16), 15);
-        assert_eq!(ctlz(1i16), 15);
-        assert_eq!(ctlz(1u32), 31);
-        assert_eq!(ctlz(1i32), 31);
-        assert_eq!(ctlz(1u64), 63);
-        assert_eq!(ctlz(1i64), 63);
-
-        assert_eq!(ctlz(10u8), 4);
-        assert_eq!(ctlz(10i8), 4);
-        assert_eq!(ctlz(10u16), 12);
-        assert_eq!(ctlz(10i16), 12);
-        assert_eq!(ctlz(10u32), 28);
-        assert_eq!(ctlz(10i32), 28);
-        assert_eq!(ctlz(10u64), 60);
-        assert_eq!(ctlz(10i64), 60);
-
-        assert_eq!(ctlz(100u8), 1);
-        assert_eq!(ctlz(100i8), 1);
-        assert_eq!(ctlz(100u16), 9);
-        assert_eq!(ctlz(100i16), 9);
-        assert_eq!(ctlz(100u32), 25);
-        assert_eq!(ctlz(100i32), 25);
-        assert_eq!(ctlz(100u64), 57);
-        assert_eq!(ctlz(100i64), 57);
-
-        assert_eq!(ctlz_nonzero(1u8), 7);
-        assert_eq!(ctlz_nonzero(1i8), 7);
-        assert_eq!(ctlz_nonzero(1u16), 15);
-        assert_eq!(ctlz_nonzero(1i16), 15);
-        assert_eq!(ctlz_nonzero(1u32), 31);
-        assert_eq!(ctlz_nonzero(1i32), 31);
-        assert_eq!(ctlz_nonzero(1u64), 63);
-        assert_eq!(ctlz_nonzero(1i64), 63);
-
-        assert_eq!(ctlz_nonzero(10u8), 4);
-        assert_eq!(ctlz_nonzero(10i8), 4);
-        assert_eq!(ctlz_nonzero(10u16), 12);
-        assert_eq!(ctlz_nonzero(10i16), 12);
-        assert_eq!(ctlz_nonzero(10u32), 28);
-        assert_eq!(ctlz_nonzero(10i32), 28);
-        assert_eq!(ctlz_nonzero(10u64), 60);
-        assert_eq!(ctlz_nonzero(10i64), 60);
-
-        assert_eq!(ctlz_nonzero(100u8), 1);
-        assert_eq!(ctlz_nonzero(100i8), 1);
-        assert_eq!(ctlz_nonzero(100u16), 9);
-        assert_eq!(ctlz_nonzero(100i16), 9);
-        assert_eq!(ctlz_nonzero(100u32), 25);
-        assert_eq!(ctlz_nonzero(100i32), 25);
-        assert_eq!(ctlz_nonzero(100u64), 57);
-        assert_eq!(ctlz_nonzero(100i64), 57);
-
-        assert_eq!(cttz(-1i8 as u8), 0);
-        assert_eq!(cttz(-1i8), 0);
-        assert_eq!(cttz(-1i16 as u16), 0);
-        assert_eq!(cttz(-1i16), 0);
-        assert_eq!(cttz(-1i32 as u32), 0);
-        assert_eq!(cttz(-1i32), 0);
-        assert_eq!(cttz(-1i64 as u64), 0);
-        assert_eq!(cttz(-1i64), 0);
-
-        assert_eq!(cttz(0u8), 8);
-        assert_eq!(cttz(0i8), 8);
-        assert_eq!(cttz(0u16), 16);
-        assert_eq!(cttz(0i16), 16);
-        assert_eq!(cttz(0u32), 32);
-        assert_eq!(cttz(0i32), 32);
-        assert_eq!(cttz(0u64), 64);
-        assert_eq!(cttz(0i64), 64);
-
-        assert_eq!(cttz(1u8), 0);
-        assert_eq!(cttz(1i8), 0);
-        assert_eq!(cttz(1u16), 0);
-        assert_eq!(cttz(1i16), 0);
-        assert_eq!(cttz(1u32), 0);
-        assert_eq!(cttz(1i32), 0);
-        assert_eq!(cttz(1u64), 0);
-        assert_eq!(cttz(1i64), 0);
-
-        assert_eq!(cttz(10u8), 1);
-        assert_eq!(cttz(10i8), 1);
-        assert_eq!(cttz(10u16), 1);
-        assert_eq!(cttz(10i16), 1);
-        assert_eq!(cttz(10u32), 1);
-        assert_eq!(cttz(10i32), 1);
-        assert_eq!(cttz(10u64), 1);
-        assert_eq!(cttz(10i64), 1);
-
-        assert_eq!(cttz(100u8), 2);
-        assert_eq!(cttz(100i8), 2);
-        assert_eq!(cttz(100u16), 2);
-        assert_eq!(cttz(100i16), 2);
-        assert_eq!(cttz(100u32), 2);
-        assert_eq!(cttz(100i32), 2);
-        assert_eq!(cttz(100u64), 2);
-        assert_eq!(cttz(100i64), 2);
-
-        assert_eq!(cttz_nonzero(-1i8 as u8), 0);
-        assert_eq!(cttz_nonzero(-1i8), 0);
-        assert_eq!(cttz_nonzero(-1i16 as u16), 0);
-        assert_eq!(cttz_nonzero(-1i16), 0);
-        assert_eq!(cttz_nonzero(-1i32 as u32), 0);
-        assert_eq!(cttz_nonzero(-1i32), 0);
-        assert_eq!(cttz_nonzero(-1i64 as u64), 0);
-        assert_eq!(cttz_nonzero(-1i64), 0);
-
-        assert_eq!(cttz_nonzero(1u8), 0);
-        assert_eq!(cttz_nonzero(1i8), 0);
-        assert_eq!(cttz_nonzero(1u16), 0);
-        assert_eq!(cttz_nonzero(1i16), 0);
-        assert_eq!(cttz_nonzero(1u32), 0);
-        assert_eq!(cttz_nonzero(1i32), 0);
-        assert_eq!(cttz_nonzero(1u64), 0);
-        assert_eq!(cttz_nonzero(1i64), 0);
-
-        assert_eq!(cttz_nonzero(10u8), 1);
-        assert_eq!(cttz_nonzero(10i8), 1);
-        assert_eq!(cttz_nonzero(10u16), 1);
-        assert_eq!(cttz_nonzero(10i16), 1);
-        assert_eq!(cttz_nonzero(10u32), 1);
-        assert_eq!(cttz_nonzero(10i32), 1);
-        assert_eq!(cttz_nonzero(10u64), 1);
-        assert_eq!(cttz_nonzero(10i64), 1);
-
-        assert_eq!(cttz_nonzero(100u8), 2);
-        assert_eq!(cttz_nonzero(100i8), 2);
-        assert_eq!(cttz_nonzero(100u16), 2);
-        assert_eq!(cttz_nonzero(100i16), 2);
-        assert_eq!(cttz_nonzero(100u32), 2);
-        assert_eq!(cttz_nonzero(100i32), 2);
-        assert_eq!(cttz_nonzero(100u64), 2);
-        assert_eq!(cttz_nonzero(100i64), 2);
+        [assert_eq!(ctpop(0u8), 0), assert_eq!(ctpop(0i8), 0)];
+        [assert_eq!(ctpop(0u16), 0), assert_eq!(ctpop(0i16), 0)];
+        [assert_eq!(ctpop(0u32), 0), assert_eq!(ctpop(0i32), 0)];
+        [assert_eq!(ctpop(0u64), 0), assert_eq!(ctpop(0i64), 0)];
+
+        [assert_eq!(ctpop(1u8), 1), assert_eq!(ctpop(1i8), 1)];
+        [assert_eq!(ctpop(1u16), 1), assert_eq!(ctpop(1i16), 1)];
+        [assert_eq!(ctpop(1u32), 1), assert_eq!(ctpop(1i32), 1)];
+        [assert_eq!(ctpop(1u64), 1), assert_eq!(ctpop(1i64), 1)];
+
+        [assert_eq!(ctpop(10u8), 2), assert_eq!(ctpop(10i8), 2)];
+        [assert_eq!(ctpop(10u16), 2), assert_eq!(ctpop(10i16), 2)];
+        [assert_eq!(ctpop(10u32), 2), assert_eq!(ctpop(10i32), 2)];
+        [assert_eq!(ctpop(10u64), 2), assert_eq!(ctpop(10i64), 2)];
+
+        [assert_eq!(ctpop(100u8), 3), assert_eq!(ctpop(100i8), 3)];
+        [assert_eq!(ctpop(100u16), 3), assert_eq!(ctpop(100i16), 3)];
+        [assert_eq!(ctpop(100u32), 3), assert_eq!(ctpop(100i32), 3)];
+        [assert_eq!(ctpop(100u64), 3), assert_eq!(ctpop(100i64), 3)];
+
+        [assert_eq!(ctpop(-1i8 as u8), 8), assert_eq!(ctpop(-1i8), 8)];
+        [assert_eq!(ctpop(-1i16 as u16), 16), assert_eq!(ctpop(-1i16), 16)];
+        [assert_eq!(ctpop(-1i32 as u32), 32), assert_eq!(ctpop(-1i32), 32)];
+        [assert_eq!(ctpop(-1i64 as u64), 64), assert_eq!(ctpop(-1i64), 64)];
+
+        [assert_eq!(ctlz(0u8), 8), assert_eq!(ctlz(0i8), 8)];
+        [assert_eq!(ctlz(0u16), 16), assert_eq!(ctlz(0i16), 16)];
+        [assert_eq!(ctlz(0u32), 32), assert_eq!(ctlz(0i32), 32)];
+        [assert_eq!(ctlz(0u64), 64), assert_eq!(ctlz(0i64), 64)];
+
+        [assert_eq!(ctlz(1u8), 7), assert_eq!(ctlz(1i8), 7)];
+        [assert_eq!(ctlz(1u16), 15), assert_eq!(ctlz(1i16), 15)];
+        [assert_eq!(ctlz(1u32), 31), assert_eq!(ctlz(1i32), 31)];
+        [assert_eq!(ctlz(1u64), 63), assert_eq!(ctlz(1i64), 63)];
+
+        [assert_eq!(ctlz(10u8), 4), assert_eq!(ctlz(10i8), 4)];
+        [assert_eq!(ctlz(10u16), 12), assert_eq!(ctlz(10i16), 12)];
+        [assert_eq!(ctlz(10u32), 28), assert_eq!(ctlz(10i32), 28)];
+        [assert_eq!(ctlz(10u64), 60), assert_eq!(ctlz(10i64), 60)];
+
+        [assert_eq!(ctlz(100u8), 1), assert_eq!(ctlz(100i8), 1)];
+        [assert_eq!(ctlz(100u16), 9), assert_eq!(ctlz(100i16), 9)];
+        [assert_eq!(ctlz(100u32), 25), assert_eq!(ctlz(100i32), 25)];
+        [assert_eq!(ctlz(100u64), 57), assert_eq!(ctlz(100i64), 57)];
+
+        [assert_eq!(ctlz_nonzero(1u8), 7), assert_eq!(ctlz_nonzero(1i8), 7)];
+        [assert_eq!(ctlz_nonzero(1u16), 15), assert_eq!(ctlz_nonzero(1i16), 15)];
+        [assert_eq!(ctlz_nonzero(1u32), 31), assert_eq!(ctlz_nonzero(1i32), 31)];
+        [assert_eq!(ctlz_nonzero(1u64), 63), assert_eq!(ctlz_nonzero(1i64), 63)];
+
+        [assert_eq!(ctlz_nonzero(10u8), 4), assert_eq!(ctlz_nonzero(10i8), 4)];
+        [assert_eq!(ctlz_nonzero(10u16), 12), assert_eq!(ctlz_nonzero(10i16), 12)];
+        [assert_eq!(ctlz_nonzero(10u32), 28), assert_eq!(ctlz_nonzero(10i32), 28)];
+        [assert_eq!(ctlz_nonzero(10u64), 60), assert_eq!(ctlz_nonzero(10i64), 60)];
+
+        [assert_eq!(ctlz_nonzero(100u8), 1), assert_eq!(ctlz_nonzero(100i8), 1)];
+        [assert_eq!(ctlz_nonzero(100u16), 9), assert_eq!(ctlz_nonzero(100i16), 9)];
+        [assert_eq!(ctlz_nonzero(100u32), 25), assert_eq!(ctlz_nonzero(100i32), 25)];
+        [assert_eq!(ctlz_nonzero(100u64), 57), assert_eq!(ctlz_nonzero(100i64), 57)];
+
+        [assert_eq!(cttz(-1i8 as u8), 0), assert_eq!(cttz(-1i8), 0)];
+        [assert_eq!(cttz(-1i16 as u16), 0), assert_eq!(cttz(-1i16), 0)];
+        [assert_eq!(cttz(-1i32 as u32), 0), assert_eq!(cttz(-1i32), 0)];
+        [assert_eq!(cttz(-1i64 as u64), 0), assert_eq!(cttz(-1i64), 0)];
+
+        [assert_eq!(cttz(0u8), 8), assert_eq!(cttz(0i8), 8)];
+        [assert_eq!(cttz(0u16), 16), assert_eq!(cttz(0i16), 16)];
+        [assert_eq!(cttz(0u32), 32), assert_eq!(cttz(0i32), 32)];
+        [assert_eq!(cttz(0u64), 64), assert_eq!(cttz(0i64), 64)];
+
+        [assert_eq!(cttz(1u8), 0), assert_eq!(cttz(1i8), 0)];
+        [assert_eq!(cttz(1u16), 0), assert_eq!(cttz(1i16), 0)];
+        [assert_eq!(cttz(1u32), 0), assert_eq!(cttz(1i32), 0)];
+        [assert_eq!(cttz(1u64), 0), assert_eq!(cttz(1i64), 0)];
+
+        [assert_eq!(cttz(10u8), 1), assert_eq!(cttz(10i8), 1)];
+        [assert_eq!(cttz(10u16), 1), assert_eq!(cttz(10i16), 1)];
+        [assert_eq!(cttz(10u32), 1), assert_eq!(cttz(10i32), 1)];
+        [assert_eq!(cttz(10u64), 1), assert_eq!(cttz(10i64), 1)];
+
+        [assert_eq!(cttz(100u8), 2), assert_eq!(cttz(100i8), 2)];
+        [assert_eq!(cttz(100u16), 2), assert_eq!(cttz(100i16), 2)];
+        [assert_eq!(cttz(100u32), 2), assert_eq!(cttz(100i32), 2)];
+        [assert_eq!(cttz(100u64), 2), assert_eq!(cttz(100i64), 2)];
+
+        [assert_eq!(cttz_nonzero(-1i8 as u8), 0), assert_eq!(cttz_nonzero(-1i8), 0)];
+        [assert_eq!(cttz_nonzero(-1i16 as u16), 0), assert_eq!(cttz_nonzero(-1i16), 0)];
+        [assert_eq!(cttz_nonzero(-1i32 as u32), 0), assert_eq!(cttz_nonzero(-1i32), 0)];
+        [assert_eq!(cttz_nonzero(-1i64 as u64), 0), assert_eq!(cttz_nonzero(-1i64), 0)];
+
+        [assert_eq!(cttz_nonzero(1u8), 0), assert_eq!(cttz_nonzero(1i8), 0)];
+        [assert_eq!(cttz_nonzero(1u16), 0), assert_eq!(cttz_nonzero(1i16), 0)];
+        [assert_eq!(cttz_nonzero(1u32), 0), assert_eq!(cttz_nonzero(1i32), 0)];
+        [assert_eq!(cttz_nonzero(1u64), 0), assert_eq!(cttz_nonzero(1i64), 0)];
+
+        [assert_eq!(cttz_nonzero(10u8), 1), assert_eq!(cttz_nonzero(10i8), 1)];
+        [assert_eq!(cttz_nonzero(10u16), 1), assert_eq!(cttz_nonzero(10i16), 1)];
+        [assert_eq!(cttz_nonzero(10u32), 1), assert_eq!(cttz_nonzero(10i32), 1)];
+        [assert_eq!(cttz_nonzero(10u64), 1), assert_eq!(cttz_nonzero(10i64), 1)];
+
+        [assert_eq!(cttz_nonzero(100u8), 2), assert_eq!(cttz_nonzero(100i8), 2)];
+        [assert_eq!(cttz_nonzero(100u16), 2), assert_eq!(cttz_nonzero(100i16), 2)];
+        [assert_eq!(cttz_nonzero(100u32), 2), assert_eq!(cttz_nonzero(100i32), 2)];
+        [assert_eq!(cttz_nonzero(100u64), 2), assert_eq!(cttz_nonzero(100i64), 2)];
 
         assert_eq!(bswap(0x0Au8), 0x0A); // no-op
         assert_eq!(bswap(0x0Ai8), 0x0A); // no-op
diff --git a/tests/pass/ptr_int_casts.rs b/tests/pass/ptr_int_casts.rs
@@ -20,8 +20,8 @@ fn ptr_int_casts() {
     *val = (1 as *const u8).wrapping_offset(-4);
     assert_eq!(*val as usize, usize::MAX - 2);
 
+    // ptr-int-ptr
     {
-        // ptr-int-ptr
         let x = 13;
         let mut y = &x as &_ as *const _ as usize;
         y += 13;
@@ -30,8 +30,8 @@ fn ptr_int_casts() {
         assert!(eq_ref(&x, unsafe { &*y }));
     }
 
+    // fnptr-int-fnptr
     {
-        // fnptr-int-fnptr
         let x: fn() -> i32 = f;
         let y: *mut u8 = unsafe { mem::transmute(x as fn() -> i32) };
         let mut y = y as usize;
diff --git a/tests/pass/sums.rs b/tests/pass/sums.rs

Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ struct Foo {`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`fn main() {`
	`13`	`+ // Try many times as this might work by chance.`
`13`	`14`	`for _ in 0..10 {`
`14`		`- // Try many times as this might work by chance.`
`15`	`15`	`let foo = Foo { x: 42, y: 99 };`
`16`	`16`	`let p = &foo.x;`
`17`	`17`	`let i = *p; //~ERROR alignment 4 is required`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ fn ptr_int_casts() {`
`20`	`20`	`val = (1 as const u8).wrapping_offset(-4);`
`21`	`21`	`assert_eq!(*val as usize, usize::MAX - 2);`
`22`	`22`
	`23`	`+ // ptr-int-ptr`
`23`	`24`	`{`
`24`		`- // ptr-int-ptr`
`25`	`25`	`let x = 13;`
`26`	`26`	`let mut y = &x as &_ as *const _ as usize;`
`27`	`27`	`y += 13;`
`@@ -30,8 +30,8 @@ fn ptr_int_casts() {`
`30`	`30`	`assert!(eq_ref(&x, unsafe { &*y }));`
`31`	`31`	`}`
`32`	`32`
	`33`	`+ // fnptr-int-fnptr`
`33`	`34`	`{`
`34`		`- // fnptr-int-fnptr`
`35`	`35`	`let x: fn() -> i32 = f;`
`36`	`36`	`let y: *mut u8 = unsafe { mem::transmute(x as fn() -> i32) };`
`37`	`37`	`let mut y = y as usize;`