[INFO] fetching crate majit-metainterp 0.0.1...
[INFO] testing majit-metainterp-0.0.1 against 1.99.0-beta.8+cargoflags=--release for beta-release-1.100-2
[INFO] extracting crate majit-metainterp 0.0.1 into /workspace/builds/worker-5-tc1/source
[INFO] started tweaking crates.io crate majit-metainterp 0.0.1
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate majit-metainterp 0.0.1
[INFO] tweaked toml for crates.io crate majit-metainterp 0.0.1 written to /workspace/builds/worker-5-tc1/source/Cargo.toml
[INFO] validating manifest of crates.io crate majit-metainterp 0.0.1 on toolchain 1.99.0-beta.8
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.99.0-beta.8" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate majit-metainterp 0.0.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.99.0-beta.8" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded majit-gc v0.0.1
[INFO] [stderr]   Downloaded majit-macros v0.0.1
[INFO] [stderr]   Downloaded majit-trace v0.0.1
[INFO] [stderr]   Downloaded majit-backend v0.0.1
[INFO] [stderr]   Downloaded wasmtime-internal-jit-icache-coherence v43.0.0
[INFO] [stderr]   Downloaded majit-ir v0.0.1
[INFO] [stderr]   Downloaded cranelift-control v0.130.0
[INFO] [stderr]   Downloaded majit-backend-wasm v0.0.1
[INFO] [stderr]   Downloaded cranelift-bitset v0.130.0
[INFO] [stderr]   Downloaded cranelift-codegen-shared v0.130.0
[INFO] [stderr]   Downloaded cranelift-native v0.130.0
[INFO] [stderr]   Downloaded cranelift-assembler-x64 v0.130.0
[INFO] [stderr]   Downloaded cranelift-module v0.130.0
[INFO] [stderr]   Downloaded cranelift-entity v0.130.0
[INFO] [stderr]   Downloaded cranelift-srcgen v0.130.0
[INFO] [stderr]   Downloaded cranelift-jit v0.130.0
[INFO] [stderr]   Downloaded wasmtime-internal-core v43.0.0
[INFO] [stderr]   Downloaded cranelift-frontend v0.130.0
[INFO] [stderr]   Downloaded cranelift-bforest v0.130.0
[INFO] [stderr]   Downloaded cranelift-assembler-x64-meta v0.130.0
[INFO] [stderr]   Downloaded cranelift-isle v0.130.0
[INFO] [stderr]   Downloaded cranelift-codegen-meta v0.130.0
[INFO] [stderr]   Downloaded regalloc2 v0.15.0
[INFO] [stderr]   Downloaded majit-backend-cranelift v0.0.1
[INFO] [stderr]   Downloaded gimli v0.33.1
[INFO] [stderr]   Downloaded cranelift-codegen v0.130.0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc1/target:/opt/rustwide/target:rw,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" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1
[INFO] running `Command { std: "docker" "start" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-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" "-w" "/opt/rustwide/workdir" "--user" "0:0" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1" "/opt/rustwide/cargo-home/bin/cargo" "+1.99.0-beta.8" "build" "--frozen" "--message-format=json" "--release", kill_on_drop: false }`
[INFO] [stderr]    Compiling hashbrown v0.16.1
[INFO] [stderr]    Compiling cranelift-srcgen v0.130.0
[INFO] [stderr]    Compiling wasmtime-internal-core v43.0.0
[INFO] [stderr]    Compiling smallvec v1.15.1
[INFO] [stderr]    Compiling cranelift-isle v0.130.0
[INFO] [stderr]    Compiling cranelift-codegen-shared v0.130.0
[INFO] [stderr]    Compiling target-lexicon v0.13.5
[INFO] [stderr]    Compiling bumpalo v3.20.2
[INFO] [stderr]    Compiling arbitrary v1.4.2
[INFO] [stderr]    Compiling rustc-hash v2.1.1
[INFO] [stderr]    Compiling hashbrown v0.15.5
[INFO] [stderr]    Compiling anyhow v1.0.102
[INFO] [stderr]    Compiling region v3.0.2
[INFO] [stderr]    Compiling cranelift-assembler-x64-meta v0.130.0
[INFO] [stderr]    Compiling majit-ir v0.0.1
[INFO] [stderr]    Compiling regalloc2 v0.15.0
[INFO] [stderr]    Compiling indexmap v2.13.0
[INFO] [stderr]    Compiling cranelift-control v0.130.0
[INFO] [stderr]    Compiling majit-gc v0.0.1
[INFO] [stderr]    Compiling majit-backend v0.0.1
[INFO] [stderr]    Compiling cranelift-codegen-meta v0.130.0
[INFO] [stderr]    Compiling cranelift-assembler-x64 v0.130.0
[INFO] [stderr]    Compiling majit-trace v0.0.1
[INFO] [stderr]    Compiling cranelift-bitset v0.130.0
[INFO] [stderr]    Compiling wasmtime-internal-jit-icache-coherence v43.0.0
[INFO] [stderr]    Compiling cranelift-entity v0.130.0
[INFO] [stderr]    Compiling gimli v0.33.1
[INFO] [stderr]    Compiling cranelift-bforest v0.130.0
[INFO] [stderr]    Compiling cranelift-codegen v0.130.0
[INFO] [stderr]    Compiling cranelift-native v0.130.0
[INFO] [stderr]    Compiling cranelift-module v0.130.0
[INFO] [stderr]    Compiling cranelift-frontend v0.130.0
[INFO] [stderr]    Compiling cranelift-jit v0.130.0
[INFO] [stderr]    Compiling majit-backend-cranelift v0.0.1
[INFO] [stderr]    Compiling majit-metainterp v0.0.1 (/opt/rustwide/workdir)
[INFO] [stdout] error: extern blocks must be unsafe
[INFO] [stdout]     --> src/pyjitpl.rs:4649:13
[INFO] [stdout]      |
[INFO] [stdout] 4649 |               extern "C" {
[INFO] [stdout]      |               ^
[INFO] [stdout]      |               |
[INFO] [stdout]      |  _____________help: needs `unsafe` before the extern keyword: `unsafe`
[INFO] [stdout]      | |
[INFO] [stdout] 4650 | |                 fn pthread_self() -> usize;
[INFO] [stdout] 4651 | |                 fn pthread_getattr_np(thread: usize, attr: *mut [u8; 64]) -> i32;
[INFO] [stdout] 4652 | |                 fn pthread_attr_getstack(
[INFO] [stdout] ...    |
[INFO] [stdout] 4657 | |                 fn pthread_attr_destroy(attr: *mut [u8; 64]) -> i32;
[INFO] [stdout] 4658 | |             }
[INFO] [stdout]      | |_____________^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/blackhole.rs:897:1
[INFO] [stdout]     |
[INFO] [stdout] 897 | / /// blackhole.py: last exception value from a residual call.
[INFO] [stdout] 898 | | /// Set by pyre call helpers (bh_call_fn_impl etc.) on error.
[INFO] [stdout] 899 | | /// Read by dispatch_one to populate exception_last_value on handler dispatch.
[INFO] [stdout]     | |_-----------------------------------------------------------------------------^
[INFO] [stdout]     |   |
[INFO] [stdout]     |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]     |
[INFO] [stdout]     = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout]     = note: `#[warn(unused_doc_comments)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/blackhole.rs:904:1
[INFO] [stdout]     |
[INFO] [stdout] 904 | / /// blackhole.py bhimpl_recursive_call: virtualizable pointer for call helpers.
[INFO] [stdout] 905 | | /// Set by the blackhole run loop before dispatch so extern "C" helpers
[INFO] [stdout] 906 | | /// (bh_call_fn_impl etc.) can access the parent frame without passing
[INFO] [stdout] 907 | | /// it through the register file.
[INFO] [stdout]     | |_--------------------------------^
[INFO] [stdout]     |   |
[INFO] [stdout]     |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]     |
[INFO] [stdout]     = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `OpRef`
[INFO] [stdout]   --> src/blackhole.rs:15:35
[INFO] [stdout]    |
[INFO] [stdout] 15 | use majit_ir::{GcRef, Op, OpCode, OpRef};
[INFO] [stdout]    |                                   ^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `resolve`
[INFO] [stdout]   --> src/blackhole.rs:17:71
[INFO] [stdout]    |
[INFO] [stdout] 17 | use crate::executor::{OpResult, TraceValues, ValueStore, execute_one, resolve};
[INFO] [stdout]    |                                                                       ^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `JitCellToken`
[INFO] [stdout]  --> src/compile.rs:9:87
[INFO] [stdout]   |
[INFO] [stdout] 9 |     Backend, CompiledTraceInfo, ExitFrameLayout, ExitRecoveryLayout, FailDescrLayout, JitCellToken,
[INFO] [stdout]   |                                                                                       ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `DescrRef`
[INFO] [stdout]   --> src/optimizeopt/optimizer.rs:15:16
[INFO] [stdout]    |
[INFO] [stdout] 15 | use majit_ir::{DescrRef, GcRef, Op, OpCode, OpRef, Type};
[INFO] [stdout]    |                ^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `Type`
[INFO] [stdout]  --> src/optimizeopt/pure.rs:9:42
[INFO] [stdout]   |
[INFO] [stdout] 9 | use majit_ir::{GcRef, Op, OpCode, OpRef, Type, Value};
[INFO] [stdout]   |                                          ^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `BinaryHeap`
[INFO] [stdout]   --> src/optimizeopt/vector.rs:33:24
[INFO] [stdout]    |
[INFO] [stdout] 33 | use std::collections::{BinaryHeap, HashMap, HashSet};
[INFO] [stdout]    |                        ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `AccumVectorInfo`
[INFO] [stdout]   --> src/optimizeopt/vector.rs:35:16
[INFO] [stdout]    |
[INFO] [stdout] 35 | use majit_ir::{AccumVectorInfo, Op, OpCode, OpRef};
[INFO] [stdout]    |                ^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around `if` condition
[INFO] [stdout]     --> src/optimizeopt/mod.rs:1350:12
[INFO] [stdout]      |
[INFO] [stdout] 1350 |         if (opnum == OpCode::GuardNoException || opnum == OpCode::GuardException) {
[INFO] [stdout]      |            ^                                                                    ^
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]      |
[INFO] [stdout] 1350 -         if (opnum == OpCode::GuardNoException || opnum == OpCode::GuardException) {
[INFO] [stdout] 1350 +         if opnum == OpCode::GuardNoException || opnum == OpCode::GuardException {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `CompiledTraceInfo`, `ExitFrameLayout`, `FailDescrLayout`, and `TerminalExitLayout`
[INFO] [stdout]  --> src/pyjitpl.rs:5:14
[INFO] [stdout]   |
[INFO] [stdout] 5 |     Backend, CompiledTraceInfo, ExitFrameLayout, ExitRecoveryLayout, FailDescrLayout, JitCellToken,
[INFO] [stdout]   |              ^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^                      ^^^^^^^^^^^^^^^
[INFO] [stdout] 6 |     TerminalExitLayout,
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `blackhole_execute_with_state`
[INFO] [stdout]   --> src/pyjitpl.rs:17:38
[INFO] [stdout]    |
[INFO] [stdout] 17 |     BlackholeResult, ExceptionState, blackhole_execute_with_state, blackhole_execute_with_state_ca,
[INFO] [stdout]    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `ResumeDataVirtualAdder` and `ResumeFrameLayoutSummary`
[INFO] [stdout]   --> src/pyjitpl.rs:28:37
[INFO] [stdout]    |
[INFO] [stdout] 28 |     ResumeData, ResumeDataLoopMemo, ResumeDataVirtualAdder, ResumeFrameLayoutSummary,
[INFO] [stdout]    |                                     ^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated function `blackhole::blackhole_execute_with_exception`: use BlackholeInterpreter for RPython-parity jitcode execution
[INFO] [stdout]    --> src/blackhole.rs:177:5
[INFO] [stdout]     |
[INFO] [stdout] 177 |     blackhole_execute_with_exception(
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(deprecated)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: use of deprecated function `blackhole::blackhole_execute`: use BlackholeInterpreter for RPython-parity jitcode execution
[INFO] [stdout]    --> src/blackhole.rs:737:18
[INFO] [stdout]     |
[INFO] [stdout] 737 |     let result = blackhole_execute(ops, constants, initial_values, start_index);
[INFO] [stdout]     |                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `Descr`
[INFO] [stdout]  --> src/optimizeopt/info.rs:7:16
[INFO] [stdout]   |
[INFO] [stdout] 7 | use majit_ir::{Descr, DescrRef, GcRef, Op, OpCode, OpRef, Value};
[INFO] [stdout]   |                ^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/blackhole.rs:2236:5
[INFO] [stdout]      |
[INFO] [stdout] 2236 |     mut bh: BlackholeInterpreter,
[INFO] [stdout]      |     ----^^
[INFO] [stdout]      |     |
[INFO] [stdout]      |     help: remove this `mut`
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/blackhole.rs:2237:5
[INFO] [stdout]      |
[INFO] [stdout] 2237 |     mut current_exc: i64,
[INFO] [stdout]      |     ----^^^^^^^^^^^
[INFO] [stdout]      |     |
[INFO] [stdout]      |     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `constants`
[INFO] [stdout]    --> src/compile.rs:145:5
[INFO] [stdout]     |
[INFO] [stdout] 145 |     constants: &std::collections::HashMap<u32, i64>,
[INFO] [stdout]     |     ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_constants`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `constant_types`
[INFO] [stdout]    --> src/compile.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 146 |     constant_types: &std::collections::HashMap<u32, Type>,
[INFO] [stdout]     |     ^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_constant_types`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `exit_types`
[INFO] [stdout]    --> src/compile.rs:781:5
[INFO] [stdout]     |
[INFO] [stdout] 781 |     exit_types: &[Type],
[INFO] [stdout]     |     ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_exit_types`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `raw_fn_ptr`
[INFO] [stdout]     --> src/compile.rs:1484:18
[INFO] [stdout]      |
[INFO] [stdout] 1484 |         let Some(raw_fn_ptr) = raw_fn else {
[INFO] [stdout]      |                  ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_raw_fn_ptr`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1118:23
[INFO] [stdout]      |
[INFO] [stdout] 1118 |             let ptr = (target as *mut u8).add(offset);
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/jit_state.rs:1110:1
[INFO] [stdout]      |
[INFO] [stdout] 1110 | / unsafe fn apply_pending_field_write(
[INFO] [stdout] 1111 | |     layout: PendingFieldWriteLayout,
[INFO] [stdout] 1112 | |     target: usize,
[INFO] [stdout] 1113 | |     item_index: Option<usize>,
[INFO] [stdout] 1114 | |     value: i64,
[INFO] [stdout] 1115 | | ) {
[INFO] [stdout]      | |_^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout]      = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `jit_state::write_typed_value` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1119:13
[INFO] [stdout]      |
[INFO] [stdout] 1119 |             write_typed_value(ptr, value, value_type);
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1127:23
[INFO] [stdout]      |
[INFO] [stdout] 1127 |             let ptr = (target as *mut u8).add(base_offset + index * item_size);
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `jit_state::write_typed_value` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1128:13
[INFO] [stdout]      |
[INFO] [stdout] 1128 |             write_typed_value(ptr, value, item_type);
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::write` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1135:22
[INFO] [stdout]      |
[INFO] [stdout] 1135 |         Type::Int => (ptr as *mut i64).write(value),
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/jit_state.rs:1133:1
[INFO] [stdout]      |
[INFO] [stdout] 1133 | unsafe fn write_typed_value(ptr: *mut u8, value: i64, value_type: Type) {
[INFO] [stdout]      | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::write` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1136:22
[INFO] [stdout]      |
[INFO] [stdout] 1136 |         Type::Ref => (ptr as *mut usize).write(value as usize),
[INFO] [stdout]      |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::write` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/jit_state.rs:1137:24
[INFO] [stdout]      |
[INFO] [stdout] 1137 |         Type::Float => (ptr as *mut f64).write(f64::from_bits(value as u64)),
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `env`
[INFO] [stdout]     --> src/jitdriver.rs:1993:9
[INFO] [stdout]      |
[INFO] [stdout] 1993 |         env: &S::Env,
[INFO] [stdout]      |         ^^^ help: if this is intentional, prefix it with an underscore: `_env`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:185:9
[INFO] [stdout]     |
[INFO] [stdout] 185 |         (*ptr).jf_frame_info = info;
[INFO] [stdout]     |         ^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:182:5
[INFO] [stdout]     |
[INFO] [stdout] 182 |     pub unsafe fn init(ptr: *mut JitFrame, info: *const JitFrameInfo, depth: usize) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:187:23
[INFO] [stdout]     |
[INFO] [stdout] 187 |         let len_ptr = (ptr as *mut u8).add(JF_FRAME_OFS) as *mut isize;
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:188:9
[INFO] [stdout]     |
[INFO] [stdout] 188 |         *len_ptr = depth as isize;
[INFO] [stdout]     |         ^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:196:20
[INFO] [stdout]     |
[INFO] [stdout] 196 |         let base = (ptr as *mut u8).add(JF_FRAME_OFS + BASEITEMOFS) as *mut isize;
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:195:5
[INFO] [stdout]     |
[INFO] [stdout] 195 |     pub unsafe fn frame_slots_mut(ptr: *mut JitFrame, len: usize) -> &'static mut [isize] {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::slice::from_raw_parts_mut` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:197:9
[INFO] [stdout]     |
[INFO] [stdout] 197 |         std::slice::from_raw_parts_mut(base, len)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:202:20
[INFO] [stdout]     |
[INFO] [stdout] 202 |         let base = (ptr as *const u8).add(JF_FRAME_OFS + BASEITEMOFS) as *const isize;
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:201:5
[INFO] [stdout]     |
[INFO] [stdout] 201 |     pub unsafe fn frame_slots(ptr: *const JitFrame, len: usize) -> &'static [isize] {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::slice::from_raw_parts` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:203:9
[INFO] [stdout]     |
[INFO] [stdout] 203 |         std::slice::from_raw_parts(base, len)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:208:23
[INFO] [stdout]     |
[INFO] [stdout] 208 |         let len_ptr = (ptr as *const u8).add(JF_FRAME_OFS + LENGTHOFS) as *const isize;
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:207:5
[INFO] [stdout]     |
[INFO] [stdout] 207 |     pub unsafe fn frame_length(ptr: *const JitFrame) -> isize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:209:9
[INFO] [stdout]     |
[INFO] [stdout] 209 |         *len_ptr
[INFO] [stdout]     |         ^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:214:16
[INFO] [stdout]     |
[INFO] [stdout] 214 |         while !(*frame).jf_forward.is_null() {
[INFO] [stdout]     |                ^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:213:5
[INFO] [stdout]     |
[INFO] [stdout] 213 |     pub unsafe fn resolve(mut frame: *mut JitFrame) -> *mut JitFrame {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:215:21
[INFO] [stdout]     |
[INFO] [stdout] 215 |             frame = (*frame).jf_forward;
[INFO] [stdout]     |                     ^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:227:9
[INFO] [stdout]     |
[INFO] [stdout] 227 |         (*ptr).jf_descr
[INFO] [stdout]     |         ^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:226:5
[INFO] [stdout]     |
[INFO] [stdout] 226 |     pub unsafe fn get_latest_descr(ptr: *const JitFrame) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:235:20
[INFO] [stdout]     |
[INFO] [stdout] 235 |         let base = (ptr as *const u8).add(JF_FRAME_OFS + BASEITEMOFS) as *const isize;
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:234:5
[INFO] [stdout]     |
[INFO] [stdout] 234 |     pub unsafe fn get_int_value(ptr: *const JitFrame, index: usize) -> isize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:236:9
[INFO] [stdout]     |
[INFO] [stdout] 236 |         *base.add(index)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:236:10
[INFO] [stdout]     |
[INFO] [stdout] 236 |         *base.add(index)
[INFO] [stdout]     |          ^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:243:20
[INFO] [stdout]     |
[INFO] [stdout] 243 |         let base = (ptr as *const u8).add(JF_FRAME_OFS + BASEITEMOFS) as *const usize;
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:242:5
[INFO] [stdout]     |
[INFO] [stdout] 242 |     pub unsafe fn get_ref_value(ptr: *const JitFrame, index: usize) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:244:9
[INFO] [stdout]     |
[INFO] [stdout] 244 |         *base.add(index)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:244:10
[INFO] [stdout]     |
[INFO] [stdout] 244 |         *base.add(index)
[INFO] [stdout]     |          ^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:249:20
[INFO] [stdout]     |
[INFO] [stdout] 249 |         let base = (ptr as *const u8).add(JF_FRAME_OFS + BASEITEMOFS) as *const u64;
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:248:5
[INFO] [stdout]     |
[INFO] [stdout] 248 |     pub unsafe fn get_float_value(ptr: *const JitFrame, index: usize) -> u64 {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:250:9
[INFO] [stdout]     |
[INFO] [stdout] 250 |         *base.add(index)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:250:10
[INFO] [stdout]     |
[INFO] [stdout] 250 |         *base.add(index)
[INFO] [stdout]     |          ^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:255:9
[INFO] [stdout]     |
[INFO] [stdout] 255 |         (*ptr).jf_savedata
[INFO] [stdout]     |         ^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:254:5
[INFO] [stdout]     |
[INFO] [stdout] 254 |     pub unsafe fn get_savedata_ref(ptr: *const JitFrame) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:260:9
[INFO] [stdout]     |
[INFO] [stdout] 260 |         (*ptr).jf_savedata = value;
[INFO] [stdout]     |         ^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:259:5
[INFO] [stdout]     |
[INFO] [stdout] 259 |     pub unsafe fn set_savedata_ref(ptr: *mut JitFrame, value: usize) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:272:9
[INFO] [stdout]     |
[INFO] [stdout] 272 |         (*ptr).jf_descr == done_descr
[INFO] [stdout]     |         ^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:271:5
[INFO] [stdout]     |
[INFO] [stdout] 271 |     pub unsafe fn is_done_with_this_frame(ptr: *const JitFrame, done_descr: usize) -> bool {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `jitframe::JitFrame::get_int_value` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:280:9
[INFO] [stdout]     |
[INFO] [stdout] 280 |         Self::get_int_value(ptr, 0)
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:279:5
[INFO] [stdout]     |
[INFO] [stdout] 279 |     pub unsafe fn get_finish_result_int(ptr: *const JitFrame) -> isize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:295:25
[INFO] [stdout]     |
[INFO] [stdout] 295 |     trace_callback(&mut (*obj_addr).jf_descr);
[INFO] [stdout]     |                         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:293:1
[INFO] [stdout]     |
[INFO] [stdout] 293 | pub unsafe fn jitframe_trace(obj_addr: *mut JitFrame, mut trace_callback: impl FnMut(*mut usize)) {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:296:25
[INFO] [stdout]     |
[INFO] [stdout] 296 |     trace_callback(&mut (*obj_addr).jf_force_descr);
[INFO] [stdout]     |                         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:297:25
[INFO] [stdout]     |
[INFO] [stdout] 297 |     trace_callback(&mut (*obj_addr).jf_savedata);
[INFO] [stdout]     |                         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:298:25
[INFO] [stdout]     |
[INFO] [stdout] 298 |     trace_callback(&mut (*obj_addr).jf_guard_exc);
[INFO] [stdout]     |                         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:299:25
[INFO] [stdout]     |
[INFO] [stdout] 299 |     trace_callback(&mut (*obj_addr).jf_forward as *mut *mut JitFrame as *mut usize);
[INFO] [stdout]     |                         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:305:21
[INFO] [stdout]     |
[INFO] [stdout] 305 |     let gcmap_raw = (*obj_addr).jf_gcmap;
[INFO] [stdout]     |                     ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:311:21
[INFO] [stdout]     |
[INFO] [stdout] 311 |     let gcmap_lgt = *(gcmap_raw.add(GCMAPLENGTHOFS) as *const isize);
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:311:23
[INFO] [stdout]     |
[INFO] [stdout] 311 |     let gcmap_lgt = *(gcmap_raw.add(GCMAPLENGTHOFS) as *const isize);
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:317:19
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let cur = *(gcmap_raw.add(GCMAPBASEOFS + UNSIGN_SIZE * no as usize) as *const usize);
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:317:21
[INFO] [stdout]     |
[INFO] [stdout] 317 |         let cur = *(gcmap_raw.add(GCMAPBASEOFS + UNSIGN_SIZE * no as usize) as *const usize);
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:325:21
[INFO] [stdout]     |
[INFO] [stdout] 325 |                     *((obj_addr as *const u8).add(JF_FRAME_OFS + LENGTHOFS) as *const isize);
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:325:23
[INFO] [stdout]     |
[INFO] [stdout] 325 |                     *((obj_addr as *const u8).add(JF_FRAME_OFS + LENGTHOFS) as *const isize);
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:333:33
[INFO] [stdout]     |
[INFO] [stdout] 333 |                   let slot_addr = (obj_addr as *mut u8)
[INFO] [stdout]     |  _________________________________^
[INFO] [stdout] 334 | |                     .add(JF_FRAME_OFS + BASEITEMOFS + SIGN_SIZE * index)
[INFO] [stdout]     | |________________________________________________________________________^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `jitframe::jitframe_trace` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/jitframe.rs:353:5
[INFO] [stdout]     |
[INFO] [stdout] 353 | /     jitframe_trace(obj_addr as *mut JitFrame, |slot_ptr| {
[INFO] [stdout] 354 | |         // GcRef and usize are both word-sized; reinterpret the slot.
[INFO] [stdout] 355 | |         f(slot_ptr as *mut majit_ir::GcRef);
[INFO] [stdout] 356 | |     });
[INFO] [stdout]     | |______^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/jitframe.rs:352:1
[INFO] [stdout]     |
[INFO] [stdout] 352 | unsafe fn jitframe_custom_trace(obj_addr: usize, f: &mut dyn FnMut(*mut majit_ir::GcRef)) {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/optimizeopt/dependency.rs:214:13
[INFO] [stdout]     |
[INFO] [stdout] 214 |         let mut nodes: Vec<Node> = ops
[INFO] [stdout]     |             ----^^^^^
[INFO] [stdout]     |             |
[INFO] [stdout]     |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `ops`
[INFO] [stdout]    --> src/optimizeopt/dependency.rs:295:88
[INFO] [stdout]     |
[INFO] [stdout] 295 |     fn build_guard_dependencies(&mut self, guard_idx: usize, tracker: &mut DefTracker, ops: &[Op]) {
[INFO] [stdout]     |                                                                                        ^^^ help: if this is intentional, prefix it with an underscore: `_ops`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `obj`
[INFO] [stdout]    --> src/optimizeopt/heap.rs:616:32
[INFO] [stdout]     |
[INFO] [stdout] 616 |         for (descr_idx, index, obj, mut op) in pending {
[INFO] [stdout]     |                                ^^^ help: if this is intentional, prefix it with an underscore: `_obj`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]     --> src/optimizeopt/intbounds.rs:1375:13
[INFO] [stdout]      |
[INFO] [stdout] 1375 |             OpCode::Strlen | OpCode::Unicodelen => {
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
[INFO] [stdout]      |
[INFO] [stdout] note: multiple earlier patterns match some of the same values
[INFO] [stdout]     --> src/optimizeopt/intbounds.rs:1375:13
[INFO] [stdout]      |
[INFO] [stdout] 1256 |             OpCode::Strlen => {
[INFO] [stdout]      |             -------------- matches some of the same values
[INFO] [stdout] ...
[INFO] [stdout] 1260 |             OpCode::Unicodelen => {
[INFO] [stdout]      |             ------------------ matches some of the same values
[INFO] [stdout] ...
[INFO] [stdout] 1375 |             OpCode::Strlen | OpCode::Unicodelen => {
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ collectively making this unreachable
[INFO] [stdout]      = note: `#[warn(unreachable_patterns)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `loop_num_inputs`
[INFO] [stdout]     --> src/optimizeopt/optimizer.rs:2244:9
[INFO] [stdout]      |
[INFO] [stdout] 2244 |         loop_num_inputs: Option<usize>,
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_loop_num_inputs`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `pos`
[INFO] [stdout]     --> src/optimizeopt/schedule.rs:1012:18
[INFO] [stdout]      |
[INFO] [stdout] 1012 |             let (pos, newarg) = state.getvector_of_box(*arg).unwrap_or((0, *arg));
[INFO] [stdout]      |                  ^^^ help: if this is intentional, prefix it with an underscore: `_pos`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/optimizeopt/shortpreamble.rs:471:21
[INFO] [stdout]     |
[INFO] [stdout] 471 |                 let mut produced = compound.flatten(sb, Vec::new());
[INFO] [stdout]     |                     ----^^^^^^^^
[INFO] [stdout]     |                     |
[INFO] [stdout]     |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `result`
[INFO] [stdout]     --> src/optimizeopt/shortpreamble.rs:1002:35
[INFO] [stdout]      |
[INFO] [stdout] 1002 |     fn append_to_short(&mut self, result: OpRef, produced: &ProducedShortOp) -> Op {
[INFO] [stdout]      |                                   ^^^^^^ help: if this is intentional, prefix it with an underscore: `_result`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `exported_infos`
[INFO] [stdout]     --> src/optimizeopt/unroll.rs:2465:9
[INFO] [stdout]      |
[INFO] [stdout] 2465 |         exported_infos: &HashMap<OpRef, ExportedValueInfo>,
[INFO] [stdout]      |         ^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_exported_infos`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/optimizeopt/unroll.rs:3315:9
[INFO] [stdout]      |
[INFO] [stdout] 3315 |     let mut next_free_pos = |mut next: u32| {
[INFO] [stdout]      |         ----^^^^^^^^^^^^^
[INFO] [stdout]      |         |
[INFO] [stdout]      |         help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `arg`
[INFO] [stdout]    --> src/optimizeopt/vector.rs:167:17
[INFO] [stdout]     |
[INFO] [stdout] 167 |             for arg in &mut jump.args {
[INFO] [stdout]     |                 ^^^ help: if this is intentional, prefix it with an underscore: `_arg`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `depth`
[INFO] [stdout]    --> src/optimizeopt/vector.rs:185:9
[INFO] [stdout]     |
[INFO] [stdout] 185 |     for depth in 0..max_depth {
[INFO] [stdout]     |         ^^^^^ help: if this is intentional, prefix it with an underscore: `_depth`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `virtual_slots`
[INFO] [stdout]     --> src/optimizeopt/mod.rs:1472:9
[INFO] [stdout]      |
[INFO] [stdout] 1472 |         virtual_slots: &[crate::optimizeopt::optimizer::VirtualFailArgSlot],
[INFO] [stdout]      |         ^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_virtual_slots`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `virtual_obj`
[INFO] [stdout]     --> src/pyjitpl.rs:1626:62
[INFO] [stdout]      |
[INFO] [stdout] 1626 |     pub fn opimpl_virtual_ref_finish(&mut self, vref: OpRef, virtual_obj: OpRef) {
[INFO] [stdout]      |                                                              ^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_virtual_obj`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/pyjitpl.rs:1696:57
[INFO] [stdout]      |
[INFO] [stdout] 1696 |     pub fn compile_loop(&mut self, jump_args: &[OpRef], mut meta: M) -> CompileOutcome {
[INFO] [stdout]      |                                                         ----^^^^
[INFO] [stdout]      |                                                         |
[INFO] [stdout]      |                                                         help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/pyjitpl.rs:2086:13
[INFO] [stdout]      |
[INFO] [stdout] 2086 |         let mut optimized_ops = compile::unbox_call_assembler_results(optimized_ops);
[INFO] [stdout]      |             ----^^^^^^^^^^^^^
[INFO] [stdout]      |             |
[INFO] [stdout]      |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/pyjitpl.rs:2087:13
[INFO] [stdout]      |
[INFO] [stdout] 2087 |         let mut optimized_ops =
[INFO] [stdout]      |             ----^^^^^^^^^^^^^
[INFO] [stdout]      |             |
[INFO] [stdout]      |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/pyjitpl.rs:3056:13
[INFO] [stdout]      |
[INFO] [stdout] 3056 |         let mut optimized_ops = match optimize_result {
[INFO] [stdout]      |             ----^^^^^^^^^^^^^
[INFO] [stdout]      |             |
[INFO] [stdout]      |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]     --> src/pyjitpl.rs:3126:13
[INFO] [stdout]      |
[INFO] [stdout] 3126 |         let mut optimized_ops = compile::strip_stray_overflow_guards(optimized_ops);
[INFO] [stdout]      |             ----^^^^^^^^^^^^^
[INFO] [stdout]      |             |
[INFO] [stdout]      |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `pos_remap1`
[INFO] [stdout]     --> src/pyjitpl.rs:2995:25
[INFO] [stdout]      |
[INFO] [stdout] 2995 |         let (trace_ops, pos_remap1) = compile::fold_box_into_create_frame(
[INFO] [stdout]      |                         ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_pos_remap1`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `pos_remap2`
[INFO] [stdout]     --> src/pyjitpl.rs:3001:25
[INFO] [stdout]      |
[INFO] [stdout] 3001 |         let (trace_ops, pos_remap2) = compile::elide_create_frame_for_call_assembler(
[INFO] [stdout]      |                         ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_pos_remap2`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:235:25
[INFO] [stdout]     |
[INFO] [stdout] 235 |         let token_ptr = obj_ptr.add(self.token_offset) as *mut u64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:234:5
[INFO] [stdout]     |
[INFO] [stdout] 234 |     pub unsafe fn tracing_before_residual_call(&self, obj_ptr: *mut u8) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:236:20
[INFO] [stdout]     |
[INFO] [stdout] 236 |         assert_eq!(*token_ptr, 0, "token should be NONE before residual call");
[INFO] [stdout]     |                    ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:237:9
[INFO] [stdout]     |
[INFO] [stdout] 237 |         *token_ptr = TOKEN_TRACING_RESCALL;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:248:25
[INFO] [stdout]     |
[INFO] [stdout] 248 |         let token_ptr = obj_ptr.add(self.token_offset) as *mut u64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:247:5
[INFO] [stdout]     |
[INFO] [stdout] 247 |     pub unsafe fn tracing_after_residual_call(&self, obj_ptr: *mut u8) -> bool {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:249:12
[INFO] [stdout]     |
[INFO] [stdout] 249 |         if *token_ptr != 0 {
[INFO] [stdout]     |            ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:251:24
[INFO] [stdout]     |
[INFO] [stdout] 251 |             assert_eq!(*token_ptr, TOKEN_TRACING_RESCALL);
[INFO] [stdout]     |                        ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:252:13
[INFO] [stdout]     |
[INFO] [stdout] 252 |             *token_ptr = 0; // Clear back to TOKEN_NONE
[INFO] [stdout]     |             ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:269:25
[INFO] [stdout]     |
[INFO] [stdout] 269 |         let token_ptr = obj_ptr.add(self.token_offset) as *mut u64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:268:5
[INFO] [stdout]     |
[INFO] [stdout] 268 |     pub unsafe fn force_now(&self, obj_ptr: *mut u8, force_fn: impl FnOnce(u64)) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:270:21
[INFO] [stdout]     |
[INFO] [stdout] 270 |         let token = *token_ptr;
[INFO] [stdout]     |                     ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:273:13
[INFO] [stdout]     |
[INFO] [stdout] 273 |             *token_ptr = 0;
[INFO] [stdout]     |             ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:277:24
[INFO] [stdout]     |
[INFO] [stdout] 277 |             assert_eq!(*token_ptr, 0, "force_fn should have cleared the token");
[INFO] [stdout]     |                        ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:286:25
[INFO] [stdout]     |
[INFO] [stdout] 286 |         let token_ptr = obj_ptr.add(self.token_offset) as *const u64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:285:5
[INFO] [stdout]     |
[INFO] [stdout] 285 |     pub unsafe fn read_token(&self, obj_ptr: *const u8) -> VableToken {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:287:30
[INFO] [stdout]     |
[INFO] [stdout] 287 |         VableToken::from_raw(*token_ptr)
[INFO] [stdout]     |                              ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:295:25
[INFO] [stdout]     |
[INFO] [stdout] 295 |         let token_ptr = obj_ptr.add(self.token_offset) as *mut u64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:294:5
[INFO] [stdout]     |
[INFO] [stdout] 294 |     pub unsafe fn write_token(&self, obj_ptr: *mut u8, token: VableToken) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:296:9
[INFO] [stdout]     |
[INFO] [stdout] 296 |         *token_ptr = token.to_raw();
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_token` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:330:9
[INFO] [stdout]     |
[INFO] [stdout] 330 |         self.write_token(obj_ptr, VableToken::None);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:329:5
[INFO] [stdout]     |
[INFO] [stdout] 329 |     pub unsafe fn reset_vable_token(&self, obj_ptr: *mut u8) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::reset_vable_token` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:338:9
[INFO] [stdout]     |
[INFO] [stdout] 338 |         self.reset_vable_token(obj_ptr);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:337:5
[INFO] [stdout]     |
[INFO] [stdout] 337 |     pub unsafe fn reset_token_gcref(&self, obj_ptr: *mut u8) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_token` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:350:22
[INFO] [stdout]     |
[INFO] [stdout] 350 |         if !matches!(self.read_token(obj_ptr), VableToken::None) {
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:345:5
[INFO] [stdout]     |
[INFO] [stdout] 345 | /     pub unsafe fn force_virtualizable_if_necessary(
[INFO] [stdout] 346 | |         &self,
[INFO] [stdout] 347 | |         obj_ptr: *mut u8,
[INFO] [stdout] 348 | |         force_fn: impl FnOnce(u64),
[INFO] [stdout] 349 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::force_now` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:351:13
[INFO] [stdout]     |
[INFO] [stdout] 351 |             self.force_now(obj_ptr, force_fn);
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::force_virtualizable_if_necessary` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:361:9
[INFO] [stdout]     |
[INFO] [stdout] 361 |         self.force_virtualizable_if_necessary(obj_ptr, force_fn);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:360:5
[INFO] [stdout]     |
[INFO] [stdout] 360 |     pub unsafe fn clear_vable_token(&self, obj_ptr: *mut u8, force_fn: impl FnOnce(u64)) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_token` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:363:22
[INFO] [stdout]     |
[INFO] [stdout] 363 |             matches!(self.read_token(obj_ptr), VableToken::None),
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:499:27
[INFO] [stdout]     |
[INFO] [stdout] 499 |                 let ptr = obj_ptr.add(field.offset) as *const f64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:495:5
[INFO] [stdout]     |
[INFO] [stdout] 495 |     pub unsafe fn read_field(&self, obj_ptr: *const u8, field_index: usize) -> i64 {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:500:30
[INFO] [stdout]     |
[INFO] [stdout] 500 |                 f64::to_bits(*ptr) as i64
[INFO] [stdout]     |                              ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:503:27
[INFO] [stdout]     |
[INFO] [stdout] 503 |                 let ptr = obj_ptr.add(field.offset) as *const i64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:504:17
[INFO] [stdout]     |
[INFO] [stdout] 504 |                 *ptr
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:519:27
[INFO] [stdout]     |
[INFO] [stdout] 519 |                 let ptr = obj_ptr.add(field.offset) as *mut f64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:515:5
[INFO] [stdout]     |
[INFO] [stdout] 515 |     pub unsafe fn write_field(&self, obj_ptr: *mut u8, field_index: usize, value: i64) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:520:17
[INFO] [stdout]     |
[INFO] [stdout] 520 |                 *ptr = f64::from_bits(value as u64);
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:523:27
[INFO] [stdout]     |
[INFO] [stdout] 523 |                 let ptr = obj_ptr.add(field.offset) as *mut i64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:524:17
[INFO] [stdout]     |
[INFO] [stdout] 524 |                 *ptr = value;
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:542:33
[INFO] [stdout]     |
[INFO] [stdout] 542 |                 let array_ptr = *(obj_ptr.add(ai.field_offset) as *const *const u8);
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:538:5
[INFO] [stdout]     |
[INFO] [stdout] 538 |     pub unsafe fn get_array_length(&self, obj_ptr: *const u8, array_index: usize) -> usize {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:542:35
[INFO] [stdout]     |
[INFO] [stdout] 542 |                 let array_ptr = *(obj_ptr.add(ai.field_offset) as *const *const u8);
[INFO] [stdout]     |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:546:21
[INFO] [stdout]     |
[INFO] [stdout] 546 |                     *(array_ptr.add(ai.length_offset) as *const usize)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:546:23
[INFO] [stdout]     |
[INFO] [stdout] 546 |                     *(array_ptr.add(ai.length_offset) as *const usize)
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:550:17
[INFO] [stdout]     |
[INFO] [stdout] 550 |                 *(obj_ptr.add(ai.field_offset + ai.length_offset) as *const usize)
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:550:19
[INFO] [stdout]     |
[INFO] [stdout] 550 |                 *(obj_ptr.add(ai.field_offset + ai.length_offset) as *const usize)
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VableArrayInfo::data_ptr` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:568:25
[INFO] [stdout]     |
[INFO] [stdout] 568 |         let array_ptr = ai.data_ptr(obj_ptr);
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:561:5
[INFO] [stdout]     |
[INFO] [stdout] 561 | /     pub unsafe fn read_array_item(
[INFO] [stdout] 562 | |         &self,
[INFO] [stdout] 563 | |         obj_ptr: *const u8,
[INFO] [stdout] 564 | |         array_index: usize,
[INFO] [stdout] 565 | |         item_index: usize,
[INFO] [stdout] 566 | |     ) -> i64 {
[INFO] [stdout]     | |____________^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:572:27
[INFO] [stdout]     |
[INFO] [stdout] 572 |                 let ptr = array_ptr.add(item_offset) as *const f64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:573:30
[INFO] [stdout]     |
[INFO] [stdout] 573 |                 f64::to_bits(*ptr) as i64
[INFO] [stdout]     |                              ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:576:27
[INFO] [stdout]     |
[INFO] [stdout] 576 |                 let ptr = array_ptr.add(item_offset) as *const i64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:577:17
[INFO] [stdout]     |
[INFO] [stdout] 577 |                 *ptr
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VableArrayInfo::data_ptr` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:596:25
[INFO] [stdout]     |
[INFO] [stdout] 596 |         let array_ptr = ai.data_ptr(obj_ptr.cast_const()) as *mut u8;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:588:5
[INFO] [stdout]     |
[INFO] [stdout] 588 | /     pub unsafe fn write_array_item(
[INFO] [stdout] 589 | |         &self,
[INFO] [stdout] 590 | |         obj_ptr: *mut u8,
[INFO] [stdout] 591 | |         array_index: usize,
[INFO] [stdout] 592 | |         item_index: usize,
[INFO] [stdout] 593 | |         value: i64,
[INFO] [stdout] 594 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:600:27
[INFO] [stdout]     |
[INFO] [stdout] 600 |                 let ptr = array_ptr.add(item_offset) as *mut f64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:601:17
[INFO] [stdout]     |
[INFO] [stdout] 601 |                 *ptr = f64::from_bits(value as u64);
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:604:27
[INFO] [stdout]     |
[INFO] [stdout] 604 |                 let ptr = array_ptr.add(item_offset) as *mut i64;
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:605:17
[INFO] [stdout]     |
[INFO] [stdout] 605 |                 *ptr = value;
[INFO] [stdout]     |                 ^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_field` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:625:24
[INFO] [stdout]     |
[INFO] [stdout] 625 |             boxes.push(self.read_field(obj_ptr, i));
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:619:5
[INFO] [stdout]     |
[INFO] [stdout] 619 |     pub unsafe fn load_list_of_boxes(&self, obj_ptr: *const u8) -> (Vec<i64>, Vec<usize>) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::get_array_length` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:630:23
[INFO] [stdout]     |
[INFO] [stdout] 630 |             let len = self.get_array_length(obj_ptr, ai);
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_array_item` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:633:28
[INFO] [stdout]     |
[INFO] [stdout] 633 |                 boxes.push(self.read_array_item(obj_ptr, ai, ei));
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::get_array_length` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:650:31
[INFO] [stdout]     |
[INFO] [stdout] 650 |             .map(|(index, _)| self.get_array_length(obj_ptr, index))
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:646:5
[INFO] [stdout]     |
[INFO] [stdout] 646 |     pub unsafe fn read_array_lengths_from_heap(&self, obj_ptr: *const u8) -> Vec<usize> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_field` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:662:31
[INFO] [stdout]     |
[INFO] [stdout] 662 |             .map(|(index, _)| self.read_field(obj_ptr, index))
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:658:5
[INFO] [stdout]     |
[INFO] [stdout] 658 |     pub unsafe fn read_boxes(&self, obj_ptr: *const u8) -> Vec<i64> {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_field` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:675:13
[INFO] [stdout]     |
[INFO] [stdout] 675 |             self.write_field(obj_ptr, index, value);
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:670:5
[INFO] [stdout]     |
[INFO] [stdout] 670 |     pub unsafe fn write_boxes(&self, obj_ptr: *mut u8, boxes: &[i64]) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_boxes` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:688:28
[INFO] [stdout]     |
[INFO] [stdout] 688 |         let static_boxes = self.read_boxes(obj_ptr);
[INFO] [stdout]     |                            ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:683:5
[INFO] [stdout]     |
[INFO] [stdout] 683 | /     pub unsafe fn read_all_boxes(
[INFO] [stdout] 684 | |         &self,
[INFO] [stdout] 685 | |         obj_ptr: *const u8,
[INFO] [stdout] 686 | |         array_lengths: &[usize],
[INFO] [stdout] 687 | |     ) -> (Vec<i64>, Vec<Vec<i64>>) {
[INFO] [stdout]     | |__________________________________^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::read_array_item` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:694:29
[INFO] [stdout]     |
[INFO] [stdout] 694 |                 values.push(self.read_array_item(obj_ptr, index, item_index));
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_boxes` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:711:9
[INFO] [stdout]     |
[INFO] [stdout] 711 |         self.write_boxes(obj_ptr, static_boxes);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:705:5
[INFO] [stdout]     |
[INFO] [stdout] 705 | /     pub unsafe fn write_all_boxes(
[INFO] [stdout] 706 | |         &self,
[INFO] [stdout] 707 | |         obj_ptr: *mut u8,
[INFO] [stdout] 708 | |         static_boxes: &[i64],
[INFO] [stdout] 709 | |         array_boxes: &[Vec<i64>],
[INFO] [stdout] 710 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_array_item` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:714:17
[INFO] [stdout]     |
[INFO] [stdout] 714 |                 self.write_array_item(obj_ptr, array_index, item_index, value);
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_field` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:734:17
[INFO] [stdout]     |
[INFO] [stdout] 734 |                 self.write_field(obj_ptr, i, boxes[i]);
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:725:5
[INFO] [stdout]     |
[INFO] [stdout] 725 | /     pub unsafe fn write_boxes_to_heap(
[INFO] [stdout] 726 | |         &self,
[INFO] [stdout] 727 | |         obj_ptr: *mut u8,
[INFO] [stdout] 728 | |         boxes: &[i64],
[INFO] [stdout] 729 | |         array_lengths: &[usize],
[INFO] [stdout] 730 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_array_item` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:743:21
[INFO] [stdout]     |
[INFO] [stdout] 743 |                     self.write_array_item(obj_ptr, ai, ei, boxes[idx]);
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_all_boxes` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:764:9
[INFO] [stdout]     |
[INFO] [stdout] 764 |         self.write_all_boxes(obj_ptr, static_boxes, array_boxes);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:758:5
[INFO] [stdout]     |
[INFO] [stdout] 758 | /     pub unsafe fn write_from_resume_data_partial(
[INFO] [stdout] 759 | |         &self,
[INFO] [stdout] 760 | |         obj_ptr: *mut u8,
[INFO] [stdout] 761 | |         static_boxes: &[i64],
[INFO] [stdout] 762 | |         array_boxes: &[Vec<i64>],
[INFO] [stdout] 763 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::write_boxes_to_heap` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:779:9
[INFO] [stdout]     |
[INFO] [stdout] 779 |         self.write_boxes_to_heap(obj_ptr, boxes, array_lengths);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:773:5
[INFO] [stdout]     |
[INFO] [stdout] 773 | /     pub unsafe fn force_from_boxes(
[INFO] [stdout] 774 | |         &self,
[INFO] [stdout] 775 | |         obj_ptr: *mut u8,
[INFO] [stdout] 776 | |         boxes: &[i64],
[INFO] [stdout] 777 | |         array_lengths: &[usize],
[INFO] [stdout] 778 | |     ) {
[INFO] [stdout]     | |_____^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `virtualizable::VirtualizableInfo::reset_vable_token` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:780:9
[INFO] [stdout]     |
[INFO] [stdout] 780 |         self.reset_vable_token(obj_ptr);
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:797:17
[INFO] [stdout]     |
[INFO] [stdout] 797 |                 *(obj_ptr.add(self.field_offset) as *const *const u8)
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:794:5
[INFO] [stdout]     |
[INFO] [stdout] 794 |     unsafe fn data_ptr(&self, obj_ptr: *const u8) -> *const u8 {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:797:19
[INFO] [stdout]     |
[INFO] [stdout] 797 |                 *(obj_ptr.add(self.field_offset) as *const *const u8)
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:800:17
[INFO] [stdout]     |
[INFO] [stdout] 800 |                 *(obj_ptr.add(self.field_offset + ptr_offset) as *const *const u8)
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:800:19
[INFO] [stdout]     |
[INFO] [stdout] 800 |                 *(obj_ptr.add(self.field_offset + ptr_offset) as *const *const u8)
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:888:21
[INFO] [stdout]     |
[INFO] [stdout] 888 |     let token_ptr = obj_ptr.add(info.token_offset) as *const u64;
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualizable.rs:887:1
[INFO] [stdout]     |
[INFO] [stdout] 887 | pub unsafe fn is_token_nonnull(info: &VirtualizableInfo, obj_ptr: *const u8) -> bool {
[INFO] [stdout]     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualizable.rs:889:5
[INFO] [stdout]     |
[INFO] [stdout] 889 |     *token_ptr != 0
[INFO] [stdout]     |     ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2026:29
[INFO] [stdout]      |
[INFO] [stdout] 2026 |             let container = vable_ptr.add(array.field_offset);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/virtualizable.rs:2022:1
[INFO] [stdout]      |
[INFO] [stdout] 2022 | pub unsafe fn vable_array_len(vable_ptr: *const u8, array: &VableArrayInfo) -> usize {
[INFO] [stdout]      | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2027:13
[INFO] [stdout]      |
[INFO] [stdout] 2027 |             *(container.add(array.length_offset) as *const usize)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2027:15
[INFO] [stdout]      |
[INFO] [stdout] 2027 |             *(container.add(array.length_offset) as *const usize)
[INFO] [stdout]      |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2031:27
[INFO] [stdout]      |
[INFO] [stdout] 2031 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *const u8);
[INFO] [stdout]      |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2031:29
[INFO] [stdout]      |
[INFO] [stdout] 2031 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *const u8);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2035:17
[INFO] [stdout]      |
[INFO] [stdout] 2035 |                 *(arr_ptr.add(array.length_offset) as *const usize)
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2035:19
[INFO] [stdout]      |
[INFO] [stdout] 2035 |                 *(arr_ptr.add(array.length_offset) as *const usize)
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2051:29
[INFO] [stdout]      |
[INFO] [stdout] 2051 |             let container = vable_ptr.add(array.field_offset);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/virtualizable.rs:2043:1
[INFO] [stdout]      |
[INFO] [stdout] 2043 | / pub unsafe fn vable_read_array_item(
[INFO] [stdout] 2044 | |     vable_ptr: *const u8,
[INFO] [stdout] 2045 | |     array: &VableArrayInfo,
[INFO] [stdout] 2046 | |     index: usize,
[INFO] [stdout] 2047 | | ) -> i64 {
[INFO] [stdout]      | |________^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2052:13
[INFO] [stdout]      |
[INFO] [stdout] 2052 |             *(container.add(ptr_offset) as *const *const u8)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2052:15
[INFO] [stdout]      |
[INFO] [stdout] 2052 |             *(container.add(ptr_offset) as *const *const u8)
[INFO] [stdout]      |               ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2055:27
[INFO] [stdout]      |
[INFO] [stdout] 2055 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *const u8);
[INFO] [stdout]      |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2055:29
[INFO] [stdout]      |
[INFO] [stdout] 2055 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *const u8);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2056:13
[INFO] [stdout]      |
[INFO] [stdout] 2056 |             arr_ptr.add(array.items_offset)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2062:19
[INFO] [stdout]      |
[INFO] [stdout] 2062 |         let src = data_ptr.add(index * item_size);
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::read` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2063:9
[INFO] [stdout]      |
[INFO] [stdout] 2063 |         std::ptr::read(src as *const i64)
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2078:29
[INFO] [stdout]      |
[INFO] [stdout] 2078 |             let container = vable_ptr.add(array.field_offset);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/virtualizable.rs:2069:1
[INFO] [stdout]      |
[INFO] [stdout] 2069 | / pub unsafe fn vable_write_array_item(
[INFO] [stdout] 2070 | |     vable_ptr: *mut u8,
[INFO] [stdout] 2071 | |     array: &VableArrayInfo,
[INFO] [stdout] 2072 | |     index: usize,
[INFO] [stdout] 2073 | |     value: i64,
[INFO] [stdout] 2074 | | ) {
[INFO] [stdout]      | |_^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2079:13
[INFO] [stdout]      |
[INFO] [stdout] 2079 |             *(container.add(ptr_offset) as *const *mut u8)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2079:15
[INFO] [stdout]      |
[INFO] [stdout] 2079 |             *(container.add(ptr_offset) as *const *mut u8)
[INFO] [stdout]      |               ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2082:27
[INFO] [stdout]      |
[INFO] [stdout] 2082 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *mut u8);
[INFO] [stdout]      |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2082:29
[INFO] [stdout]      |
[INFO] [stdout] 2082 |             let arr_ptr = *(vable_ptr.add(array.field_offset) as *const *mut u8);
[INFO] [stdout]      |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2083:13
[INFO] [stdout]      |
[INFO] [stdout] 2083 |             arr_ptr.add(array.items_offset)
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2087:20
[INFO] [stdout]      |
[INFO] [stdout] 2087 |         let dest = data_ptr.add(index * item_size);
[INFO] [stdout]      |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::write` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2088:9
[INFO] [stdout]      |
[INFO] [stdout] 2088 |         std::ptr::write(dest as *mut i64, value);
[INFO] [stdout]      |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2101:21
[INFO] [stdout]      |
[INFO] [stdout] 2101 |     let token_ptr = obj_ptr.add(vinfo.token_offset) as *mut u64;
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]      |
[INFO] [stdout]      = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]     --> src/virtualizable.rs:2100:1
[INFO] [stdout]      |
[INFO] [stdout] 2100 | pub unsafe fn bh_clear_vable_token(vinfo: &VirtualizableInfo, obj_ptr: *mut u8) {
[INFO] [stdout]      | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2102:17
[INFO] [stdout]      |
[INFO] [stdout] 2102 |     let token = *token_ptr;
[INFO] [stdout]      |                 ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]     --> src/virtualizable.rs:2106:9
[INFO] [stdout]      |
[INFO] [stdout] 2106 |         *token_ptr = 0;
[INFO] [stdout]      |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]      |
[INFO] [stdout]      = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]      = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:108:25
[INFO] [stdout]     |
[INFO] [stdout] 108 |         let token_ptr = vref_ptr.add(self.descr_virtual_token as usize * 8) as *mut i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 | /     pub unsafe fn force_virtual(
[INFO] [stdout] 104 | |         &self,
[INFO] [stdout] 105 | |         vref_ptr: *mut u8,
[INFO] [stdout] 106 | |         force_fn: impl FnOnce(i64) -> *mut u8,
[INFO] [stdout] 107 | |     ) -> *mut u8 {
[INFO] [stdout]     | |________________^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:109:26
[INFO] [stdout]     |
[INFO] [stdout] 109 |         let forced_ptr = vref_ptr.add(self.descr_forced as usize * 8) as *mut *mut u8;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:110:21
[INFO] [stdout]     |
[INFO] [stdout] 110 |         let token = *token_ptr;
[INFO] [stdout]     |                     ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:114:20
[INFO] [stdout]     |
[INFO] [stdout] 114 |             return *forced_ptr;
[INFO] [stdout]     |                    ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:119:13
[INFO] [stdout]     |
[INFO] [stdout] 119 |             *token_ptr = TOKEN_NONE;
[INFO] [stdout]     |             ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:120:20
[INFO] [stdout]     |
[INFO] [stdout] 120 |             return *forced_ptr;
[INFO] [stdout]     |                    ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:125:9
[INFO] [stdout]     |
[INFO] [stdout] 125 |         *forced_ptr = materialized;
[INFO] [stdout]     |         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:126:9
[INFO] [stdout]     |
[INFO] [stdout] 126 |         *token_ptr = TOKEN_NONE;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:149:25
[INFO] [stdout]     |
[INFO] [stdout] 149 |         let token_ptr = vref_ptr.add(self.descr_virtual_token as usize * 8) as *mut i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:148:5
[INFO] [stdout]     |
[INFO] [stdout] 148 |     pub unsafe fn tracing_before_residual_call(&self, vref_ptr: *mut u8) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:150:9
[INFO] [stdout]     |
[INFO] [stdout] 150 |         *token_ptr = TOKEN_TRACING_RESCALL;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:166:25
[INFO] [stdout]     |
[INFO] [stdout] 166 |         let token_ptr = vref_ptr.add(self.descr_virtual_token as usize * 8) as *mut i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:161:5
[INFO] [stdout]     |
[INFO] [stdout] 161 | /     pub unsafe fn tracing_after_residual_call(
[INFO] [stdout] 162 | |         &self,
[INFO] [stdout] 163 | |         vref_ptr: *mut u8,
[INFO] [stdout] 164 | |         original_token: i64,
[INFO] [stdout] 165 | |     ) -> bool {
[INFO] [stdout]     | |_____________^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:167:29
[INFO] [stdout]     |
[INFO] [stdout] 167 |         let current_token = *token_ptr;
[INFO] [stdout]     |                             ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:175:9
[INFO] [stdout]     |
[INFO] [stdout] 175 |         *token_ptr = original_token;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:187:25
[INFO] [stdout]     |
[INFO] [stdout] 187 |         let token_ptr = vref_ptr.add(self.descr_virtual_token as usize * 8) as *mut i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:186:5
[INFO] [stdout]     |
[INFO] [stdout] 186 |     pub unsafe fn continue_tracing(&self, vref_ptr: *mut u8, real_object: *mut u8) {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:188:26
[INFO] [stdout]     |
[INFO] [stdout] 188 |         let forced_ptr = vref_ptr.add(self.descr_forced as usize * 8) as *mut *mut u8;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:189:9
[INFO] [stdout]     |
[INFO] [stdout] 189 |         *forced_ptr = real_object;
[INFO] [stdout]     |         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:190:9
[INFO] [stdout]     |
[INFO] [stdout] 190 |         *token_ptr = TOKEN_NONE;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:223:25
[INFO] [stdout]     |
[INFO] [stdout] 223 |         let token_ptr = ptr.add(self.descr_virtual_token as usize * 8) as *const i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:217:5
[INFO] [stdout]     |
[INFO] [stdout] 217 |     pub unsafe fn is_virtual_ref(&self, ptr: *const u8) -> bool {
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:224:21
[INFO] [stdout]     |
[INFO] [stdout] 224 |         let token = *token_ptr;
[INFO] [stdout]     |                     ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:239:25
[INFO] [stdout]     |
[INFO] [stdout] 239 |         let token_ptr = vref_ptr.add(self.descr_virtual_token as usize * 8) as *mut i64;
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default
[INFO] [stdout]    --> src/virtualref.rs:234:5
[INFO] [stdout]     |
[INFO] [stdout] 234 | /     pub unsafe fn force_virtual_full(
[INFO] [stdout] 235 | |         &self,
[INFO] [stdout] 236 | |         vref_ptr: *mut u8,
[INFO] [stdout] 237 | |         force_fn: impl FnOnce(i64) -> *mut u8,
[INFO] [stdout] 238 | |     ) -> *mut u8 {
[INFO] [stdout]     | |________________^
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: call to unsafe function `std::ptr::mut_ptr::<impl *mut T>::add` is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:240:26
[INFO] [stdout]     |
[INFO] [stdout] 240 |         let forced_ptr = vref_ptr.add(self.descr_forced as usize * 8) as *mut *mut u8;
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
[INFO] [stdout]     |
[INFO] [stdout]     = note: consult the function's documentation for information on how to avoid undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:241:21
[INFO] [stdout]     |
[INFO] [stdout] 241 |         let token = *token_ptr;
[INFO] [stdout]     |                     ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:245:20
[INFO] [stdout]     |
[INFO] [stdout] 245 |             return *forced_ptr;
[INFO] [stdout]     |                    ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:251:13
[INFO] [stdout]     |
[INFO] [stdout] 251 |             *token_ptr = TOKEN_NONE;
[INFO] [stdout]     |             ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:252:20
[INFO] [stdout]     |
[INFO] [stdout] 252 |             return *forced_ptr;
[INFO] [stdout]     |                    ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:257:9
[INFO] [stdout]     |
[INFO] [stdout] 257 |         *forced_ptr = materialized;
[INFO] [stdout]     |         ^^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
[INFO] [stdout]    --> src/virtualref.rs:258:9
[INFO] [stdout]     |
[INFO] [stdout] 258 |         *token_ptr = TOKEN_NONE;
[INFO] [stdout]     |         ^^^^^^^^^^ dereference of raw pointer
[INFO] [stdout]     |
[INFO] [stdout]     = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0133`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `majit-metainterp` (lib) due to 1 previous error; 209 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1", kill_on_drop: false }`
[INFO] [stdout] 1d74b8160db911ae29a94b086ed720e0db4e0af092388aca8678e2e93e9f4af1
