[INFO] fetching crate coaster-nn 0.5.0...
[INFO] testing coaster-nn-0.5.0 against beta-2025-09-21 for beta-1.91-3
[INFO] extracting crate coaster-nn 0.5.0 into /workspace/builds/worker-2-tc2/source
[INFO] started tweaking crates.io crate coaster-nn 0.5.0
[INFO] finished tweaking crates.io crate coaster-nn 0.5.0
[INFO] tweaked toml for crates.io crate coaster-nn 0.5.0 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate coaster-nn 0.5.0 on toolchain beta-2025-09-21
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2025-09-21" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2025-09-21" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 36 packages to latest compatible versions
[INFO] [stderr]       Adding rand v0.8.5 (available: v0.9.2)
[INFO] [stderr]       Adding rand_chacha v0.3.1 (available: v0.9.0)
[INFO] [stderr]       Adding thiserror v1.0.69 (available: v2.0.17)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2025-09-21" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:e90291280db7d1fac5b66fc6dad9f9662629e7365a55743daf9bdf73ebc4ea79" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-09-21" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 41876ae2f6e572e75112588372e5331d4fefea0fad16c77e10279827661a6634
[INFO] running `Command { std: "docker" "start" "-a" "41876ae2f6e572e75112588372e5331d4fefea0fad16c77e10279827661a6634", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "41876ae2f6e572e75112588372e5331d4fefea0fad16c77e10279827661a6634", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "41876ae2f6e572e75112588372e5331d4fefea0fad16c77e10279827661a6634", kill_on_drop: false }`
[INFO] [stdout] 41876ae2f6e572e75112588372e5331d4fefea0fad16c77e10279827661a6634
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:e90291280db7d1fac5b66fc6dad9f9662629e7365a55743daf9bdf73ebc4ea79" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-09-21" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] c008f29a98f60d319457affa7e1765f18ca67ed4f3d66fa8eba6d5c46f9b0930
[INFO] running `Command { std: "docker" "start" "-a" "c008f29a98f60d319457affa7e1765f18ca67ed4f3d66fa8eba6d5c46f9b0930", kill_on_drop: false }`
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling unicode-ident v1.0.19
[INFO] [stderr]    Compiling log v0.4.28
[INFO] [stderr]    Compiling libc v0.2.176
[INFO] [stderr]    Compiling rcublas-sys v0.5.0
[INFO] [stderr]    Compiling zerocopy v0.8.27
[INFO] [stderr]    Compiling rcudnn-sys v0.5.0
[INFO] [stderr]    Compiling proc-macro2 v1.0.101
[INFO] [stderr]    Compiling quote v1.0.41
[INFO] [stderr]    Compiling syn v2.0.106
[INFO] [stderr]    Compiling num-integer v0.1.46
[INFO] [stderr]    Compiling num-complex v0.4.6
[INFO] [stderr]    Compiling num-traits v0.1.43
[INFO] [stderr]    Compiling enum_primitive v0.1.1
[INFO] [stderr]    Compiling num-bigint v0.4.6
[INFO] [stderr]    Compiling num-iter v0.1.45
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling ppv-lite86 v0.2.21
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling rand v0.8.5
[INFO] [stderr]    Compiling num-rational v0.4.2
[INFO] [stderr]    Compiling num v0.4.3
[INFO] [stderr]    Compiling thiserror-impl v1.0.69
[INFO] [stderr]    Compiling thiserror v1.0.69
[INFO] [stderr]    Compiling rcublas v0.6.0
[INFO] [stderr]    Compiling rcudnn v1.8.0
[INFO] [stderr]    Compiling coaster v0.2.0
[INFO] [stderr]    Compiling coaster-nn v0.5.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:452:13
[INFO] [stdout]     |
[INFO] [stdout] 452 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: `#[warn(integer_to_ptr_transmutes)]` on by default
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:454:13
[INFO] [stdout]     |
[INFO] [stdout] 454 |             trans_mut!(r_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:477:13
[INFO] [stdout]     |
[INFO] [stdout] 477 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:479:13
[INFO] [stdout]     |
[INFO] [stdout] 479 |             trans!(dx_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:481:13
[INFO] [stdout]     |
[INFO] [stdout] 481 |             trans!(r_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:483:13
[INFO] [stdout]     |
[INFO] [stdout] 483 |             trans_mut!(dr_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:616:13
[INFO] [stdout]     |
[INFO] [stdout] 616 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:617:13
[INFO] [stdout]     |
[INFO] [stdout] 617 |             trans!(f_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:619:13
[INFO] [stdout]     |
[INFO] [stdout] 619 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:621:13
[INFO] [stdout]     |
[INFO] [stdout] 621 |             trans_mut!(r_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:643:13
[INFO] [stdout]     |
[INFO] [stdout] 643 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:645:13
[INFO] [stdout]     |
[INFO] [stdout] 645 |             trans!(s_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:647:13
[INFO] [stdout]     |
[INFO] [stdout] 647 |             trans!(dd_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:648:13
[INFO] [stdout]     |
[INFO] [stdout] 648 |             trans_mut!(df_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:672:13
[INFO] [stdout]     |
[INFO] [stdout] 672 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:673:13
[INFO] [stdout]     |
[INFO] [stdout] 673 |             trans!(f_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:675:13
[INFO] [stdout]     |
[INFO] [stdout] 675 |             trans!(dx_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:677:13
[INFO] [stdout]     |
[INFO] [stdout] 677 |             trans_mut!(dr_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:982:13
[INFO] [stdout]     |
[INFO] [stdout] 982 |             trans!(src_mem),
[INFO] [stdout]     |             --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:984:13
[INFO] [stdout]     |
[INFO] [stdout] 984 |             trans_mut!(output_mem),
[INFO] [stdout]     |             ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:990:13
[INFO] [stdout]     |
[INFO] [stdout] 990 |             trans!(weight_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:995:13
[INFO] [stdout]     |
[INFO] [stdout] 995 |             trans_mut!(workspace_mem),
[INFO] [stdout]     |             ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1033:13
[INFO] [stdout]      |
[INFO] [stdout] 1033 |             trans!(output_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1036:13
[INFO] [stdout]      |
[INFO] [stdout] 1036 |             trans!(output_gradient_mem),
[INFO] [stdout]      |             --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1044:13
[INFO] [stdout]      |
[INFO] [stdout] 1044 |             trans!(weight_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1050:13
[INFO] [stdout]      |
[INFO] [stdout] 1050 |             trans_mut!(src_gradient_mem),
[INFO] [stdout]      |             ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1055:13
[INFO] [stdout]      |
[INFO] [stdout] 1055 |             trans_mut!(workspace_mem),
[INFO] [stdout]      |             ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1088:13
[INFO] [stdout]      |
[INFO] [stdout] 1088 |             trans!(src_mem),
[INFO] [stdout]      |             --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1092:13
[INFO] [stdout]      |
[INFO] [stdout] 1092 |             trans!(output_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1094:13
[INFO] [stdout]      |
[INFO] [stdout] 1094 |             trans_mut!(filter_mem),
[INFO] [stdout]      |             ---------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1095:13
[INFO] [stdout]      |
[INFO] [stdout] 1095 |             trans_mut!(workspace_mem),
[INFO] [stdout]      |             ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1115:13
[INFO] [stdout]      |
[INFO] [stdout] 1115 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1117:13
[INFO] [stdout]      |
[INFO] [stdout] 1117 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1138:13
[INFO] [stdout]      |
[INFO] [stdout] 1138 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1140:13
[INFO] [stdout]      |
[INFO] [stdout] 1140 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1142:13
[INFO] [stdout]      |
[INFO] [stdout] 1142 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1144:13
[INFO] [stdout]      |
[INFO] [stdout] 1144 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1164:13
[INFO] [stdout]      |
[INFO] [stdout] 1164 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1166:13
[INFO] [stdout]      |
[INFO] [stdout] 1166 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1190:13
[INFO] [stdout]      |
[INFO] [stdout] 1190 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1192:13
[INFO] [stdout]      |
[INFO] [stdout] 1192 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1194:13
[INFO] [stdout]      |
[INFO] [stdout] 1194 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1196:13
[INFO] [stdout]      |
[INFO] [stdout] 1196 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1216:13
[INFO] [stdout]      |
[INFO] [stdout] 1216 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1218:13
[INFO] [stdout]      |
[INFO] [stdout] 1218 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1239:13
[INFO] [stdout]      |
[INFO] [stdout] 1239 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1241:13
[INFO] [stdout]      |
[INFO] [stdout] 1241 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1243:13
[INFO] [stdout]      |
[INFO] [stdout] 1243 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1245:13
[INFO] [stdout]      |
[INFO] [stdout] 1245 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1265:13
[INFO] [stdout]      |
[INFO] [stdout] 1265 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1267:13
[INFO] [stdout]      |
[INFO] [stdout] 1267 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1290:13
[INFO] [stdout]      |
[INFO] [stdout] 1290 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1292:13
[INFO] [stdout]      |
[INFO] [stdout] 1292 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1294:13
[INFO] [stdout]      |
[INFO] [stdout] 1294 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1296:13
[INFO] [stdout]      |
[INFO] [stdout] 1296 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1315:13
[INFO] [stdout]      |
[INFO] [stdout] 1315 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1317:13
[INFO] [stdout]      |
[INFO] [stdout] 1317 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1337:13
[INFO] [stdout]      |
[INFO] [stdout] 1337 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1339:13
[INFO] [stdout]      |
[INFO] [stdout] 1339 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1341:13
[INFO] [stdout]      |
[INFO] [stdout] 1341 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1343:13
[INFO] [stdout]      |
[INFO] [stdout] 1343 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1362:13
[INFO] [stdout]      |
[INFO] [stdout] 1362 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1364:13
[INFO] [stdout]      |
[INFO] [stdout] 1364 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1384:13
[INFO] [stdout]      |
[INFO] [stdout] 1384 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1386:13
[INFO] [stdout]      |
[INFO] [stdout] 1386 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1388:13
[INFO] [stdout]      |
[INFO] [stdout] 1388 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1407:13
[INFO] [stdout]      |
[INFO] [stdout] 1407 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1409:13
[INFO] [stdout]      |
[INFO] [stdout] 1409 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1428:13
[INFO] [stdout]      |
[INFO] [stdout] 1428 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1430:13
[INFO] [stdout]      |
[INFO] [stdout] 1430 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1432:13
[INFO] [stdout]      |
[INFO] [stdout] 1432 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1464:17
[INFO] [stdout]      |
[INFO] [stdout] 1464 |                 trans!(x_mem),
[INFO] [stdout]      |                 ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1466:17
[INFO] [stdout]      |
[INFO] [stdout] 1466 |                 trans_mut!(r_mem),
[INFO] [stdout]      |                 ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1492:13
[INFO] [stdout]      |
[INFO] [stdout] 1492 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1494:13
[INFO] [stdout]      |
[INFO] [stdout] 1494 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1496:13
[INFO] [stdout]      |
[INFO] [stdout] 1496 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1498:13
[INFO] [stdout]      |
[INFO] [stdout] 1498 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1550:17
[INFO] [stdout]      |
[INFO] [stdout] 1550 |                 trans!(x_mem),
[INFO] [stdout]      |                 ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1552:17
[INFO] [stdout]      |
[INFO] [stdout] 1552 |                 trans_mut!(r_mem),
[INFO] [stdout]      |                 ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1578:13
[INFO] [stdout]      |
[INFO] [stdout] 1578 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1580:13
[INFO] [stdout]      |
[INFO] [stdout] 1580 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1582:13
[INFO] [stdout]      |
[INFO] [stdout] 1582 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1584:13
[INFO] [stdout]      |
[INFO] [stdout] 1584 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1604:13
[INFO] [stdout]      |
[INFO] [stdout] 1604 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1606:13
[INFO] [stdout]      |
[INFO] [stdout] 1606 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1631:13
[INFO] [stdout]      |
[INFO] [stdout] 1631 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1633:13
[INFO] [stdout]      |
[INFO] [stdout] 1633 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1635:13
[INFO] [stdout]      |
[INFO] [stdout] 1635 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1637:13
[INFO] [stdout]      |
[INFO] [stdout] 1637 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1666:13
[INFO] [stdout]      |
[INFO] [stdout] 1666 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1668:13
[INFO] [stdout]      |
[INFO] [stdout] 1668 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 7.41s
[INFO] running `Command { std: "docker" "inspect" "c008f29a98f60d319457affa7e1765f18ca67ed4f3d66fa8eba6d5c46f9b0930", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c008f29a98f60d319457affa7e1765f18ca67ed4f3d66fa8eba6d5c46f9b0930", kill_on_drop: false }`
[INFO] [stdout] c008f29a98f60d319457affa7e1765f18ca67ed4f3d66fa8eba6d5c46f9b0930
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:e90291280db7d1fac5b66fc6dad9f9662629e7365a55743daf9bdf73ebc4ea79" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2025-09-21" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 17aa698086532ade610f828e7ffe526566cdabc599de79d4a4a9bdc705cc4f26
[INFO] running `Command { std: "docker" "start" "-a" "17aa698086532ade610f828e7ffe526566cdabc599de79d4a4a9bdc705cc4f26", kill_on_drop: false }`
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:452:13
[INFO] [stdout]     |
[INFO] [stdout] 452 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: `#[warn(integer_to_ptr_transmutes)]` on by default
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:454:13
[INFO] [stdout]     |
[INFO] [stdout] 454 |             trans_mut!(r_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:477:13
[INFO] [stdout]     |
[INFO] [stdout] 477 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:479:13
[INFO] [stdout]     |
[INFO] [stdout] 479 |             trans!(dx_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:481:13
[INFO] [stdout]     |
[INFO] [stdout] 481 |             trans!(r_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:483:13
[INFO] [stdout]     |
[INFO] [stdout] 483 |             trans_mut!(dr_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:616:13
[INFO] [stdout]     |
[INFO] [stdout] 616 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:617:13
[INFO] [stdout]     |
[INFO] [stdout] 617 |             trans!(f_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:619:13
[INFO] [stdout]     |
[INFO] [stdout] 619 |             trans!(x_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:621:13
[INFO] [stdout]     |
[INFO] [stdout] 621 |             trans_mut!(r_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:643:13
[INFO] [stdout]     |
[INFO] [stdout] 643 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:645:13
[INFO] [stdout]     |
[INFO] [stdout] 645 |             trans!(s_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:647:13
[INFO] [stdout]     |
[INFO] [stdout] 647 |             trans!(dd_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:648:13
[INFO] [stdout]     |
[INFO] [stdout] 648 |             trans_mut!(df_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:672:13
[INFO] [stdout]     |
[INFO] [stdout] 672 |             trans_mut!(w_mem),
[INFO] [stdout]     |             ----------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:673:13
[INFO] [stdout]     |
[INFO] [stdout] 673 |             trans!(f_mem),
[INFO] [stdout]     |             ------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:675:13
[INFO] [stdout]     |
[INFO] [stdout] 675 |             trans!(dx_mem),
[INFO] [stdout]     |             -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:677:13
[INFO] [stdout]     |
[INFO] [stdout] 677 |             trans_mut!(dr_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:982:13
[INFO] [stdout]     |
[INFO] [stdout] 982 |             trans!(src_mem),
[INFO] [stdout]     |             --------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:984:13
[INFO] [stdout]     |
[INFO] [stdout] 984 |             trans_mut!(output_mem),
[INFO] [stdout]     |             ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]     |
[INFO] [stdout]  25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:990:13
[INFO] [stdout]     |
[INFO] [stdout] 990 |             trans!(weight_mem),
[INFO] [stdout]     |             ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]    --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]     |
[INFO] [stdout]  31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/frameworks/cuda/mod.rs:995:13
[INFO] [stdout]     |
[INFO] [stdout] 995 |             trans_mut!(workspace_mem),
[INFO] [stdout]     |             ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]     = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]     = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]     = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]     = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]     = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]     |
[INFO] [stdout]  31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]  31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1033:13
[INFO] [stdout]      |
[INFO] [stdout] 1033 |             trans!(output_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1036:13
[INFO] [stdout]      |
[INFO] [stdout] 1036 |             trans!(output_gradient_mem),
[INFO] [stdout]      |             --------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1044:13
[INFO] [stdout]      |
[INFO] [stdout] 1044 |             trans!(weight_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1050:13
[INFO] [stdout]      |
[INFO] [stdout] 1050 |             trans_mut!(src_gradient_mem),
[INFO] [stdout]      |             ---------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1055:13
[INFO] [stdout]      |
[INFO] [stdout] 1055 |             trans_mut!(workspace_mem),
[INFO] [stdout]      |             ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1088:13
[INFO] [stdout]      |
[INFO] [stdout] 1088 |             trans!(src_mem),
[INFO] [stdout]      |             --------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1092:13
[INFO] [stdout]      |
[INFO] [stdout] 1092 |             trans!(output_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1094:13
[INFO] [stdout]      |
[INFO] [stdout] 1094 |             trans_mut!(filter_mem),
[INFO] [stdout]      |             ---------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1095:13
[INFO] [stdout]      |
[INFO] [stdout] 1095 |             trans_mut!(workspace_mem),
[INFO] [stdout]      |             ------------------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1115:13
[INFO] [stdout]      |
[INFO] [stdout] 1115 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1117:13
[INFO] [stdout]      |
[INFO] [stdout] 1117 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1138:13
[INFO] [stdout]      |
[INFO] [stdout] 1138 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1140:13
[INFO] [stdout]      |
[INFO] [stdout] 1140 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1142:13
[INFO] [stdout]      |
[INFO] [stdout] 1142 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1144:13
[INFO] [stdout]      |
[INFO] [stdout] 1144 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1164:13
[INFO] [stdout]      |
[INFO] [stdout] 1164 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1166:13
[INFO] [stdout]      |
[INFO] [stdout] 1166 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1190:13
[INFO] [stdout]      |
[INFO] [stdout] 1190 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1192:13
[INFO] [stdout]      |
[INFO] [stdout] 1192 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1194:13
[INFO] [stdout]      |
[INFO] [stdout] 1194 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1196:13
[INFO] [stdout]      |
[INFO] [stdout] 1196 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1216:13
[INFO] [stdout]      |
[INFO] [stdout] 1216 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1218:13
[INFO] [stdout]      |
[INFO] [stdout] 1218 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1239:13
[INFO] [stdout]      |
[INFO] [stdout] 1239 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1241:13
[INFO] [stdout]      |
[INFO] [stdout] 1241 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1243:13
[INFO] [stdout]      |
[INFO] [stdout] 1243 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1245:13
[INFO] [stdout]      |
[INFO] [stdout] 1245 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1265:13
[INFO] [stdout]      |
[INFO] [stdout] 1265 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1267:13
[INFO] [stdout]      |
[INFO] [stdout] 1267 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1290:13
[INFO] [stdout]      |
[INFO] [stdout] 1290 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1292:13
[INFO] [stdout]      |
[INFO] [stdout] 1292 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1294:13
[INFO] [stdout]      |
[INFO] [stdout] 1294 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1296:13
[INFO] [stdout]      |
[INFO] [stdout] 1296 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1315:13
[INFO] [stdout]      |
[INFO] [stdout] 1315 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1317:13
[INFO] [stdout]      |
[INFO] [stdout] 1317 |             trans_mut!(x_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1337:13
[INFO] [stdout]      |
[INFO] [stdout] 1337 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1339:13
[INFO] [stdout]      |
[INFO] [stdout] 1339 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1341:13
[INFO] [stdout]      |
[INFO] [stdout] 1341 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1343:13
[INFO] [stdout]      |
[INFO] [stdout] 1343 |             trans_mut!(dx_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1362:13
[INFO] [stdout]      |
[INFO] [stdout] 1362 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1364:13
[INFO] [stdout]      |
[INFO] [stdout] 1364 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1384:13
[INFO] [stdout]      |
[INFO] [stdout] 1384 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1386:13
[INFO] [stdout]      |
[INFO] [stdout] 1386 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1388:13
[INFO] [stdout]      |
[INFO] [stdout] 1388 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1407:13
[INFO] [stdout]      |
[INFO] [stdout] 1407 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1409:13
[INFO] [stdout]      |
[INFO] [stdout] 1409 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1428:13
[INFO] [stdout]      |
[INFO] [stdout] 1428 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1430:13
[INFO] [stdout]      |
[INFO] [stdout] 1430 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1432:13
[INFO] [stdout]      |
[INFO] [stdout] 1432 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1464:17
[INFO] [stdout]      |
[INFO] [stdout] 1464 |                 trans!(x_mem),
[INFO] [stdout]      |                 ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1466:17
[INFO] [stdout]      |
[INFO] [stdout] 1466 |                 trans_mut!(r_mem),
[INFO] [stdout]      |                 ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1492:13
[INFO] [stdout]      |
[INFO] [stdout] 1492 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1494:13
[INFO] [stdout]      |
[INFO] [stdout] 1494 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1496:13
[INFO] [stdout]      |
[INFO] [stdout] 1496 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1498:13
[INFO] [stdout]      |
[INFO] [stdout] 1498 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1550:17
[INFO] [stdout]      |
[INFO] [stdout] 1550 |                 trans!(x_mem),
[INFO] [stdout]      |                 ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1552:17
[INFO] [stdout]      |
[INFO] [stdout] 1552 |                 trans_mut!(r_mem),
[INFO] [stdout]      |                 ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling coaster-nn v0.5.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1578:13
[INFO] [stdout]      |
[INFO] [stdout] 1578 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1580:13
[INFO] [stdout]      |
[INFO] [stdout] 1580 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1582:13
[INFO] [stdout]      |
[INFO] [stdout] 1582 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1584:13
[INFO] [stdout]      |
[INFO] [stdout] 1584 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1604:13
[INFO] [stdout]      |
[INFO] [stdout] 1604 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1606:13
[INFO] [stdout]      |
[INFO] [stdout] 1606 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1631:13
[INFO] [stdout]      |
[INFO] [stdout] 1631 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1633:13
[INFO] [stdout]      |
[INFO] [stdout] 1633 |             trans!(dx_mem),
[INFO] [stdout]      |             -------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1635:13
[INFO] [stdout]      |
[INFO] [stdout] 1635 |             trans!(r_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1637:13
[INFO] [stdout]      |
[INFO] [stdout] 1637 |             trans_mut!(dr_mem),
[INFO] [stdout]      |             ------------------ in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:25:18
[INFO] [stdout]      |
[INFO] [stdout]   25 |         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1666:13
[INFO] [stdout]      |
[INFO] [stdout] 1666 |             trans!(x_mem),
[INFO] [stdout]      |             ------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   25 -         unsafe { ::std::mem::transmute::<u64, *const ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   25 +         unsafe { std::ptr::with_exposed_provenance::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: transmuting an integer to a pointer creates a pointer without provenance
[INFO] [stdout]     --> src/frameworks/cuda/helper.rs:31:18
[INFO] [stdout]      |
[INFO] [stdout]   31 |         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]     ::: src/frameworks/cuda/mod.rs:1668:13
[INFO] [stdout]      |
[INFO] [stdout] 1668 |             trans_mut!(r_mem),
[INFO] [stdout]      |             ----------------- in this macro invocation
[INFO] [stdout]      |
[INFO] [stdout]      = note: this is dangerous because dereferencing the resulting pointer is undefined behavior
[INFO] [stdout]      = note: exposed provenance semantics can be used to create a pointer based on some previously exposed provenance
[INFO] [stdout]      = help: if you truly mean to create a pointer without provenance, use `std::ptr::without_provenance_mut`
[INFO] [stdout]      = help: for more information about transmute, see <https://doc.rust-lang.org/std/mem/fn.transmute.html#transmutation-between-pointers-and-integers>
[INFO] [stdout]      = help: for more information about exposed provenance, see <https://doc.rust-lang.org/std/ptr/index.html#exposed-provenance>
[INFO] [stdout]      = note: this warning originates in the macro `trans_mut` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use `std::ptr::with_exposed_provenance_mut` instead to use a previously exposed provenance
[INFO] [stdout]      |
[INFO] [stdout]   31 -         unsafe { ::std::mem::transmute::<u64, *mut ::libc::c_void>(*$mem.id_c()) }
[INFO] [stdout]   31 +         unsafe { std::ptr::with_exposed_provenance_mut::<c_void>(*$mem.id_c()) }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `num`
[INFO] [stdout]   --> src/tests/mod.rs:22:9
[INFO] [stdout]    |
[INFO] [stdout] 22 | pub use num::{One, Zero};
[INFO] [stdout]    |         ^^^ help: a similar path exists: `std::num`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0432]: unresolved import `env_logger`
[INFO] [stdout]    --> src/tests/rnn.rs:112:9
[INFO] [stdout]     |
[INFO] [stdout] 112 |     use env_logger as _;
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^ no external crate `env_logger`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `RnnPaddingMode` and `self`
[INFO] [stdout]  --> src/tests/rnn.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 |     self, DirectionMode, RnnAlgorithm, RnnConfig, RnnInputMode, RnnNetworkMode, RnnPaddingMode,
[INFO] [stdout]   |     ^^^^                                                                        ^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0433]: failed to resolve: use of unresolved module or unlinked crate `env_logger`
[INFO] [stdout]   --> src/tests/rnn.rs:17:13
[INFO] [stdout]    |
[INFO] [stdout] 17 |     let _ = env_logger::builder()
[INFO] [stdout]    |             ^^^^^^^^^^ use of unresolved module or unlinked crate `env_logger`
[INFO] [stdout]    |
[INFO] [stdout]    = help: if you wanted to use a crate named `env_logger`, use `cargo add env_logger` to add it to your `Cargo.toml`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0432, E0433.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0432`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `coaster-nn` (lib test) due to 3 previous errors; 1 warning emitted
[INFO] running `Command { std: "docker" "inspect" "17aa698086532ade610f828e7ffe526566cdabc599de79d4a4a9bdc705cc4f26", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "17aa698086532ade610f828e7ffe526566cdabc599de79d4a4a9bdc705cc4f26", kill_on_drop: false }`
[INFO] [stdout] 17aa698086532ade610f828e7ffe526566cdabc599de79d4a4a9bdc705cc4f26
