Add example of reversed pointer bytes being rejected

Let's add an example demonstrating that reversing the order of pointer
bytes causes compilation to fail, even though all bytes are present.
The compiler tracks the position of each byte within its original
pointer and only accepts pointers when reassembled in the correct
order.

This example copies a pointer byte-by-byte in reverse order into the
padding of a struct, which fails because the fragment indices don't
match up to form a valid pointer.

Context: rust-lang/rust#144081

Author: traviscross

src/const_eval.md

@@ -263,6 +263,32 @@ const C: Pair = unsafe {
 > The bytes with provenance must form a complete pointer in the correct order.  In the example above, the pointer is written at offset 20, but it requires (on 64-bit platforms) 8 bytes.  Only 4 of those bytes fit in the padding at offset 24, so the remaining bytes of the pointer extend into the `y` field at offset 16.  When the fields are initialized, those bytes get overwritten, leaving only a partial pointer (4 bytes) in the padding.  These 4 bytes have provenance but don't form a complete pointer, causing compilation to fail.
 >
 > The restriction ensures that any bytes with provenance in the final value represent complete, valid pointers in their natural representation.  The compiler cannot support pointer fragments because it would be unable to reason about them at compile time.
+>
+> Reversing the order of the pointer bytes also causes compilation to fail, even though all bytes are present:
+>
+> ```rust,compile_fail
+> # use std::mem::MaybeUninit;
+> # #[repr(C)]
+> # struct Pair {
+> #     x: u128,
+> #     y: MaybeUninit<u64>,
+> # }
+> const C: Pair = unsafe {
+>     let mut m = MaybeUninit::<Pair>::uninit();
+>     let ptr: *const u8 = &0;
+>     let ptr_bytes = &ptr as *const _ as *const MaybeUninit<u8>;
+>     // Write pointer bytes in reverse order into the padding.
+>     let dst = m.as_mut_ptr().cast::<MaybeUninit<u8>>().add(24);
+>     let mut i = 0;
+>     while i < 8 {
+>         dst.add(i).write(ptr_bytes.add(7 - i).read());
+>         i += 1;
+>     }
+>     (*m.as_mut_ptr()).x = 0;
+>     (*m.as_mut_ptr()).y = MaybeUninit::new(0);
+>     m.assume_init()
+> };
+> ```
 
 > [!NOTE]
 > Manually initializing (e.g., zeroing) the padding bytes ensures the final value is accepted: