Hello, I'm trying to write a bare-metal loader for a binary blob and I currently have:

```rust
#![no_std]
#![no_main]
use core::panic::PanicInfo;

const TARGET_ADDR: usize = 0x100000;

#[panic_handler]
fn panic(_: &PanicInfo<'_>) -> ! {
    loop {}
}

#[unsafe(no_mangle)]
pub extern "C" fn main() -> ! {
    unsafe {
        let dst = TARGET_ADDR as *mut u8;
        let payload = include_bytes!("payload.bin");

        core::ptr::copy(payload.as_ptr(), dst, payload.len());

        let payload_fn: extern "C" fn() -> ! = core::mem::transmute(TARGET_ADDR);
        payload_fn();
    }
}
```

However, the DEST_ADDR and the data included from `include_bytes!` overlap. `core::ptr::copy` is emitting a `memcpy` intrinsic and so the copy fails.  I can hand-roll a reverse copy loop but I'm trying to understand why the compiler is emitting `mempy` rather than `memmove`.  My only thought is that `include_bytes!` returns a `& 'static`, so is the compiler assuming I can't write to that location so therefore there would never be any overlap?