@salang/sa 0.1.3 → 0.1.4

package/sa_std/math.sa

@@ -0,0 +1,84 @@
+[MACRO] MATH_ABS_I64 %out_value, %value
+    is_negative = slt %value, 0
+    br is_negative -> L_MATH_ABS_NEG_%i, L_MATH_ABS_POS_%i
+L_MATH_ABS_NEG_%i:
+    neg_value = sub 0, %value
+    %out_value = add neg_value, 0
+    !neg_value
+    !is_negative
+    jmp L_MATH_ABS_END_%i
+L_MATH_ABS_POS_%i:
+    %out_value = add %value, 0
+    !is_negative
+L_MATH_ABS_END_%i:
+    !%value
+[END_MACRO]
+
+[MACRO] MATH_MIN_U64 %out_value, %lhs, %rhs
+    take_lhs = ult %lhs, %rhs
+    br take_lhs -> L_MATH_MIN_LHS_%i, L_MATH_MIN_RHS_%i
+L_MATH_MIN_LHS_%i:
+    %out_value = add %lhs, 0
+    !take_lhs
+    jmp L_MATH_MIN_END_%i
+L_MATH_MIN_RHS_%i:
+    %out_value = add %rhs, 0
+    !take_lhs
+L_MATH_MIN_END_%i:
+    !%lhs
+    !%rhs
+[END_MACRO]
+
+// Rust method-name alias over MATH_MIN_U64.
+[MACRO] MATH_MIN %out_value, %lhs, %rhs
+    EXPAND MATH_MIN_U64 %out_value, %lhs, %rhs
+[END_MACRO]
+
+[MACRO] MATH_MAX_U64 %out_value, %lhs, %rhs
+    take_lhs = ugt %lhs, %rhs
+    br take_lhs -> L_MATH_MAX_LHS_%i, L_MATH_MAX_RHS_%i
+L_MATH_MAX_LHS_%i:
+    %out_value = add %lhs, 0
+    !take_lhs
+    jmp L_MATH_MAX_END_%i
+L_MATH_MAX_RHS_%i:
+    %out_value = add %rhs, 0
+    !take_lhs
+L_MATH_MAX_END_%i:
+    !%lhs
+    !%rhs
+[END_MACRO]
+
+// Rust method-name alias over MATH_MAX_U64.
+[MACRO] MATH_MAX %out_value, %lhs, %rhs
+    EXPAND MATH_MAX_U64 %out_value, %lhs, %rhs
+[END_MACRO]
+
+[MACRO] MATH_CLAMP_U64 %out_value, %value, %min_value, %max_value
+    below_min = ult %value, %min_value
+    br below_min -> L_MATH_CLAMP_MIN_%i, L_MATH_CLAMP_CHECK_MAX_%i
+L_MATH_CLAMP_MIN_%i:
+    %out_value = add %min_value, 0
+    !below_min
+    jmp L_MATH_CLAMP_END_%i
+L_MATH_CLAMP_CHECK_MAX_%i:
+    above_max = ugt %value, %max_value
+    br above_max -> L_MATH_CLAMP_MAX_%i, L_MATH_CLAMP_VALUE_%i
+L_MATH_CLAMP_MAX_%i:
+    %out_value = add %max_value, 0
+    !above_max
+    jmp L_MATH_CLAMP_END_%i
+L_MATH_CLAMP_VALUE_%i:
+    %out_value = add %value, 0
+    !above_max
+L_MATH_CLAMP_END_%i:
+    !below_min
+    !%value
+    !%min_value
+    !%max_value
+[END_MACRO]
+
+// Rust method-name alias over MATH_CLAMP_U64.
+[MACRO] MATH_CLAMP %out_value, %value, %min_value, %max_value
+    EXPAND MATH_CLAMP_U64 %out_value, %value, %min_value, %max_value
+[END_MACRO]

package/sa_std/math.sai

@@ -0,0 +1,10 @@
+// SA-facing contracts for float math (v0.24a supplement for the Haxe
+// SA target's Math.* surface; ts-plugin precedent for naming).
+// Pure functions over f64; no handles, no failure modes.
+@extern sa_math_floor(x: f64) -> f64
+@extern sa_math_ceil(x: f64) -> f64
+@extern sa_math_sqrt(x: f64) -> f64
+@extern sa_math_sin(x: f64) -> f64
+@extern sa_math_cos(x: f64) -> f64
+@extern sa_math_pow(base: f64, exp: f64) -> f64
+@extern sa_math_random() -> f64

package/sa_std/mem/manually_drop.sa

@@ -0,0 +1,3 @@
+// ManuallyDrop namespace facade.
+@import "../mem.sal"
+@import "../mem.sa"

package/sa_std/mem/manually_drop.sal

@@ -0,0 +1 @@
+@import "../mem.sal"

package/sa_std/mem/prelude.sa

@@ -0,0 +1,2 @@
+// Stable memory namespace aggregation.
+@import "../mem.sa"

package/sa_std/mem/prelude.sal

@@ -0,0 +1,2 @@
+// ABI/layout companion for memory namespace aggregation.
+@import "../mem.sal"

package/sa_std/mem.sa

@@ -0,0 +1,564 @@
+@import "mem.sal"
+@import "core/slice.sal"
+@import "hash.sa"
+@import "cmp.sal"
+
+[MACRO] MEM_SIZE_OF_BOOL %out_size
+    %out_size = add 0, MEM_SIZE_BOOL
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_U8 %out_size
+    %out_size = add 0, MEM_SIZE_U8
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_U16 %out_size
+    %out_size = add 0, MEM_SIZE_U16
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_U32 %out_size
+    %out_size = add 0, MEM_SIZE_U32
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_U64 %out_size
+    %out_size = add 0, MEM_SIZE_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_SIZE_OF_U64.
+[MACRO] MEM_SIZE_OF %out_size
+    EXPAND MEM_SIZE_OF_U64 %out_size
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_USIZE %out_size
+    %out_size = add 0, MEM_SIZE_USIZE
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_VAL_U64 %out_size, %value_ptr
+    %out_size = add 0, MEM_SIZE_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_SIZE_OF_VAL_U64.
+[MACRO] MEM_SIZE_OF_VAL %out_size, %value_ptr
+    EXPAND MEM_SIZE_OF_VAL_U64 %out_size, %value_ptr
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_VAL_RAW_U64 %out_size, %value_ptr
+    %out_size = add 0, MEM_SIZE_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_SIZE_OF_VAL_RAW_U64.
+[MACRO] MEM_SIZE_OF_VAL_RAW %out_size, %value_ptr
+    EXPAND MEM_SIZE_OF_VAL_RAW_U64 %out_size, %value_ptr
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_I8 %out_size
+    %out_size = add 0, MEM_SIZE_I8
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_I16 %out_size
+    %out_size = add 0, MEM_SIZE_I16
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_I32 %out_size
+    %out_size = add 0, MEM_SIZE_I32
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_I64 %out_size
+    %out_size = add 0, MEM_SIZE_I64
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_ISIZE %out_size
+    %out_size = add 0, MEM_SIZE_ISIZE
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_BOOL %out_align
+    %out_align = add 0, MEM_ALIGN_BOOL
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_U8 %out_align
+    %out_align = add 0, MEM_ALIGN_U8
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_U16 %out_align
+    %out_align = add 0, MEM_ALIGN_U16
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_U32 %out_align
+    %out_align = add 0, MEM_ALIGN_U32
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_U64 %out_align
+    %out_align = add 0, MEM_ALIGN_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_ALIGN_OF_U64.
+[MACRO] MEM_ALIGN_OF %out_align
+    EXPAND MEM_ALIGN_OF_U64 %out_align
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_USIZE %out_align
+    %out_align = add 0, MEM_ALIGN_USIZE
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_VAL_U64 %out_align, %value_ptr
+    %out_align = add 0, MEM_ALIGN_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_ALIGN_OF_VAL_U64.
+[MACRO] MEM_ALIGN_OF_VAL %out_align, %value_ptr
+    EXPAND MEM_ALIGN_OF_VAL_U64 %out_align, %value_ptr
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_VAL_RAW_U64 %out_align, %value_ptr
+    %out_align = add 0, MEM_ALIGN_U64
+[END_MACRO]
+
+// Rust method-name alias over MEM_ALIGN_OF_VAL_RAW_U64.
+[MACRO] MEM_ALIGN_OF_VAL_RAW %out_align, %value_ptr
+    EXPAND MEM_ALIGN_OF_VAL_RAW_U64 %out_align, %value_ptr
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_I8 %out_align
+    %out_align = add 0, MEM_ALIGN_I8
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_I16 %out_align
+    %out_align = add 0, MEM_ALIGN_I16
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_I32 %out_align
+    %out_align = add 0, MEM_ALIGN_I32
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_I64 %out_align
+    %out_align = add 0, MEM_ALIGN_I64
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_ISIZE %out_align
+    %out_align = add 0, MEM_ALIGN_ISIZE
+[END_MACRO]
+
+[MACRO] MEM_SWAP_U64 %lhs_ptr, %rhs_ptr
+    __mem_swap_lhs_%lhs_ptr = load %lhs_ptr+0 as u64
+    __mem_swap_rhs_%lhs_ptr = load %rhs_ptr+0 as u64
+    store %lhs_ptr+0, __mem_swap_rhs_%lhs_ptr as u64
+    store %rhs_ptr+0, __mem_swap_lhs_%lhs_ptr as u64
+    !__mem_swap_rhs_%lhs_ptr
+    !__mem_swap_lhs_%lhs_ptr
+[END_MACRO]
+
+// Rust method-name alias over MEM_SWAP_U64.
+[MACRO] MEM_SWAP %lhs_ptr, %rhs_ptr
+    EXPAND MEM_SWAP_U64 %lhs_ptr, %rhs_ptr
+[END_MACRO]
+
+[MACRO] MEM_REPLACE_U64 %out_old, %slot_ptr, %new_value
+    %out_old = load %slot_ptr+0 as u64
+    store %slot_ptr+0, %new_value as u64
+[END_MACRO]
+
+// Rust method-name alias over MEM_REPLACE_U64.
+[MACRO] MEM_REPLACE %out_old, %slot_ptr, %new_value
+    EXPAND MEM_REPLACE_U64 %out_old, %slot_ptr, %new_value
+[END_MACRO]
+
+[MACRO] MEM_TAKE_U64 %out_old, %slot_ptr
+    %out_old = load %slot_ptr+0 as u64
+    store %slot_ptr+0, 0 as u64
+[END_MACRO]
+
+// Rust method-name alias over MEM_TAKE_U64.
+[MACRO] MEM_TAKE %out_old, %slot_ptr
+    EXPAND MEM_TAKE_U64 %out_old, %slot_ptr
+[END_MACRO]
+
+[MACRO] MEM_FORGET_U64 %value
+    __mem_forget_sink_%value = add %value, 0
+    !__mem_forget_sink_%value
+[END_MACRO]
+
+// Rust method-name alias over MEM_FORGET_U64.
+[MACRO] MEM_FORGET %value
+    EXPAND MEM_FORGET_U64 %value
+[END_MACRO]
+
+[MACRO] MEM_DROP_U64 %value
+    __mem_drop_sink_%value = add %value, 0
+    !__mem_drop_sink_%value
+[END_MACRO]
+
+// Rust method-name alias over MEM_DROP_U64.
+[MACRO] MEM_DROP %value
+    EXPAND MEM_DROP_U64 %value
+[END_MACRO]
+
+[MACRO] MEM_COPY_U64 %out_value, %value_ptr
+    %out_value = load %value_ptr+0 as u64
+[END_MACRO]
+
+// Rust method-name alias over MEM_COPY_U64.
+[MACRO] MEM_COPY %out_value, %value_ptr
+    EXPAND MEM_COPY_U64 %out_value, %value_ptr
+[END_MACRO]
+
+[MACRO] MEM_NEEDS_DROP_PRIMITIVE %out_bool
+    %out_bool = add 0, 0
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_UNINIT %slot_ptr
+    store %slot_ptr+MaybeUninitU64_value, 0 as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_NEW %slot_ptr, %value
+    store %slot_ptr+MaybeUninitU64_value, %value as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_WRITE %slot_ptr, %value
+    store %slot_ptr+MaybeUninitU64_value, %value as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_AS_PTR %out_ptr, %slot_ptr
+    %out_ptr = ptr_add %slot_ptr, MaybeUninitU64_value
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_AS_MUT_PTR %out_ptr, %slot_ptr
+    %out_ptr = ptr_add %slot_ptr, MaybeUninitU64_value
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ASSUME_INIT_REF %out_ptr, %slot_ptr
+    EXPAND MAYBE_UNINIT_U64_AS_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ASSUME_INIT_MUT %out_ptr, %slot_ptr
+    EXPAND MAYBE_UNINIT_U64_AS_MUT_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ASSUME_INIT %out_value, %slot_ptr
+    %out_value = load %slot_ptr+MaybeUninitU64_value as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ASSUME_INIT_READ %out_value, %slot_ptr
+    %out_value = load %slot_ptr+MaybeUninitU64_value as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ASSUME_INIT_DROP %slot_ptr
+    store %slot_ptr+MaybeUninitU64_value, 0 as u64
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_AS_BYTES %out_slice, %slot_ptr
+    __maybe_bytes_ptr_%out_slice = ptr_add %slot_ptr, MaybeUninitU64_value
+    store %out_slice+Slice_ptr, __maybe_bytes_ptr_%out_slice as ptr
+    store %out_slice+Slice_len, MEM_SIZE_U64 as u64
+    !__maybe_bytes_ptr_%out_slice
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_AS_BYTES_MUT %out_slice, %slot_ptr
+    EXPAND MAYBE_UNINIT_U64_AS_BYTES %out_slice, %slot_ptr
+[END_MACRO]
+
+[MACRO] MAYBE_UNINIT_U64_ZEROED %slot_ptr
+    store %slot_ptr+MaybeUninitU64_value, 0 as u64
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_NEW %slot_ptr, %value
+    store %slot_ptr+ManuallyDropU64_value, %value as u64
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_NEW.
+[MACRO] MANUALLY_DROP_NEW %slot_ptr, %value
+    EXPAND MANUALLY_DROP_U64_NEW %slot_ptr, %value
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_DEFAULT %slot_ptr
+    store %slot_ptr+ManuallyDropU64_value, 0 as u64
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_DEFAULT.
+[MACRO] MANUALLY_DROP_DEFAULT %slot_ptr
+    EXPAND MANUALLY_DROP_U64_DEFAULT %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_COPY %dst_slot, %src_slot
+    __manually_drop_u64_copy_value_%dst_slot = load %src_slot+ManuallyDropU64_value as u64
+    store %dst_slot+ManuallyDropU64_value, __manually_drop_u64_copy_value_%dst_slot as u64
+    !__manually_drop_u64_copy_value_%dst_slot
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_COPY.
+[MACRO] MANUALLY_DROP_COPY %dst_slot, %src_slot
+    EXPAND MANUALLY_DROP_U64_COPY %dst_slot, %src_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_CLONE %dst_slot, %src_slot
+    EXPAND MANUALLY_DROP_U64_COPY %dst_slot, %src_slot
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_CLONE.
+[MACRO] MANUALLY_DROP_CLONE %dst_slot, %src_slot
+    EXPAND MANUALLY_DROP_U64_CLONE %dst_slot, %src_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_CLONE_FROM %dst_slot, %src_slot
+    EXPAND MANUALLY_DROP_U64_COPY %dst_slot, %src_slot
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_CLONE_FROM.
+[MACRO] MANUALLY_DROP_CLONE_FROM %dst_slot, %src_slot
+    EXPAND MANUALLY_DROP_U64_CLONE_FROM %dst_slot, %src_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_INTO_INNER %out_value, %slot_ptr
+    %out_value = load %slot_ptr+ManuallyDropU64_value as u64
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_INTO_INNER.
+[MACRO] MANUALLY_DROP_INTO_INNER %out_value, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_INTO_INNER %out_value, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_TAKE %out_value, %slot_ptr
+    %out_value = load %slot_ptr+ManuallyDropU64_value as u64
+    store %slot_ptr+ManuallyDropU64_value, 0 as u64
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_TAKE.
+[MACRO] MANUALLY_DROP_TAKE %out_value, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_TAKE %out_value, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_DROP %slot_ptr
+    store %slot_ptr+ManuallyDropU64_value, 0 as u64
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_DROP.
+[MACRO] MANUALLY_DROP_DROP %slot_ptr
+    EXPAND MANUALLY_DROP_U64_DROP %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_AS_PTR %out_ptr, %slot_ptr
+    %out_ptr = ptr_add %slot_ptr, ManuallyDropU64_value
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_AS_PTR.
+[MACRO] MANUALLY_DROP_AS_PTR %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_AS_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_AS_MUT_PTR %out_ptr, %slot_ptr
+    %out_ptr = ptr_add %slot_ptr, ManuallyDropU64_value
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_AS_MUT_PTR.
+[MACRO] MANUALLY_DROP_AS_MUT_PTR %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_AS_MUT_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_DEREF %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_AS_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_DEREF.
+[MACRO] MANUALLY_DROP_DEREF %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_DEREF %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_DEREF_MUT %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_AS_MUT_PTR %out_ptr, %slot_ptr
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_DEREF_MUT.
+[MACRO] MANUALLY_DROP_DEREF_MUT %out_ptr, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_DEREF_MUT %out_ptr, %slot_ptr
+[END_MACRO]
+
+[MACRO] DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64 %hasher, %slot_ptr
+    __manually_drop_u64_hash_value_%hasher = load %slot_ptr+ManuallyDropU64_value as u64
+    EXPAND DEFAULT_HASHER_WRITE_U64 %hasher, __manually_drop_u64_hash_value_%hasher
+    !__manually_drop_u64_hash_value_%hasher
+[END_MACRO]
+
+// Rust method-name alias over DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64.
+[MACRO] DEFAULT_HASHER_WRITE_MANUALLY_DROP %hasher, %slot_ptr
+    EXPAND DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64 %hasher, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_HASH %out_hash, %slot_ptr
+    __manually_drop_u64_hash_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND DEFAULT_HASHER_NEW __manually_drop_u64_hash_hasher_%out_hash
+    EXPAND DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64 __manually_drop_u64_hash_hasher_%out_hash, %slot_ptr
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __manually_drop_u64_hash_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_HASH.
+[MACRO] MANUALLY_DROP_HASH %out_hash, %slot_ptr
+    EXPAND MANUALLY_DROP_U64_HASH %out_hash, %slot_ptr
+[END_MACRO]
+
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_MANUALLY_DROP_U64 %out_hash, %builder, %slot_ptr
+    __build_hash_one_manually_drop_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND BUILD_HASHER_DEFAULT_BUILD __build_hash_one_manually_drop_u64_hasher_%out_hash, %builder
+    EXPAND DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64 __build_hash_one_manually_drop_u64_hasher_%out_hash, %slot_ptr
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __build_hash_one_manually_drop_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over BUILD_HASHER_DEFAULT_HASH_ONE_MANUALLY_DROP_U64.
+[MACRO] BUILD_HASHER_DEFAULT_HASH_ONE_MANUALLY_DROP %out_hash, %builder, %slot_ptr
+    EXPAND BUILD_HASHER_DEFAULT_HASH_ONE_MANUALLY_DROP_U64 %out_hash, %builder, %slot_ptr
+[END_MACRO]
+
+[MACRO] RANDOM_STATE_HASH_ONE_MANUALLY_DROP_U64 %out_hash, %state, %slot_ptr
+    __random_state_hash_one_manually_drop_u64_hasher_%out_hash = stack_alloc DefaultHasher_SIZE
+    EXPAND RANDOM_STATE_BUILD __random_state_hash_one_manually_drop_u64_hasher_%out_hash, %state
+    EXPAND DEFAULT_HASHER_WRITE_MANUALLY_DROP_U64 __random_state_hash_one_manually_drop_u64_hasher_%out_hash, %slot_ptr
+    EXPAND DEFAULT_HASHER_FINISH %out_hash, __random_state_hash_one_manually_drop_u64_hasher_%out_hash
+[END_MACRO]
+
+// Rust method-name alias over RANDOM_STATE_HASH_ONE_MANUALLY_DROP_U64.
+[MACRO] RANDOM_STATE_HASH_ONE_MANUALLY_DROP %out_hash, %state, %slot_ptr
+    EXPAND RANDOM_STATE_HASH_ONE_MANUALLY_DROP_U64 %out_hash, %state, %slot_ptr
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_EQ %out_bool, %left_slot, %right_slot
+    __manually_drop_u64_eq_left_%out_bool = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_eq_right_%out_bool = load %right_slot+ManuallyDropU64_value as u64
+    %out_bool = eq __manually_drop_u64_eq_left_%out_bool, __manually_drop_u64_eq_right_%out_bool
+    !__manually_drop_u64_eq_right_%out_bool
+    !__manually_drop_u64_eq_left_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_EQ.
+[MACRO] MANUALLY_DROP_EQ %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_EQ %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_NE %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_EQ __manually_drop_u64_ne_eq_%out_bool, %left_slot, %right_slot
+    %out_bool = eq __manually_drop_u64_ne_eq_%out_bool, 0
+    !__manually_drop_u64_ne_eq_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_NE.
+[MACRO] MANUALLY_DROP_NE %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_NE %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_CMP %out_ordering, %left_slot, %right_slot
+    __manually_drop_u64_cmp_left_%out_ordering = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_cmp_right_%out_ordering = load %right_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_cmp_lt_%out_ordering = ult __manually_drop_u64_cmp_left_%out_ordering, __manually_drop_u64_cmp_right_%out_ordering
+    br __manually_drop_u64_cmp_lt_%out_ordering -> L_MANUALLY_DROP_U64_CMP_LESS_%out_ordering, L_MANUALLY_DROP_U64_CMP_CHECK_GT_%out_ordering
+L_MANUALLY_DROP_U64_CMP_LESS_%out_ordering:
+    %out_ordering = add 0, CMP_ORDERING_LESS
+    jmp L_MANUALLY_DROP_U64_CMP_DONE_%out_ordering
+L_MANUALLY_DROP_U64_CMP_CHECK_GT_%out_ordering:
+    __manually_drop_u64_cmp_gt_%out_ordering = ugt __manually_drop_u64_cmp_left_%out_ordering, __manually_drop_u64_cmp_right_%out_ordering
+    br __manually_drop_u64_cmp_gt_%out_ordering -> L_MANUALLY_DROP_U64_CMP_GREATER_%out_ordering, L_MANUALLY_DROP_U64_CMP_EQUAL_%out_ordering
+L_MANUALLY_DROP_U64_CMP_GREATER_%out_ordering:
+    %out_ordering = add 0, CMP_ORDERING_GREATER
+    !__manually_drop_u64_cmp_gt_%out_ordering
+    jmp L_MANUALLY_DROP_U64_CMP_DONE_%out_ordering
+L_MANUALLY_DROP_U64_CMP_EQUAL_%out_ordering:
+    %out_ordering = add 0, CMP_ORDERING_EQUAL
+    !__manually_drop_u64_cmp_gt_%out_ordering
+L_MANUALLY_DROP_U64_CMP_DONE_%out_ordering:
+    !__manually_drop_u64_cmp_lt_%out_ordering
+    !__manually_drop_u64_cmp_right_%out_ordering
+    !__manually_drop_u64_cmp_left_%out_ordering
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_CMP.
+[MACRO] MANUALLY_DROP_CMP %out_ordering, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_CMP %out_ordering, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_PARTIAL_CMP %out_ordering, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_CMP %out_ordering, %left_slot, %right_slot
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_PARTIAL_CMP.
+[MACRO] MANUALLY_DROP_PARTIAL_CMP %out_ordering, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_PARTIAL_CMP %out_ordering, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_LT %out_bool, %left_slot, %right_slot
+    __manually_drop_u64_lt_left_%out_bool = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_lt_right_%out_bool = load %right_slot+ManuallyDropU64_value as u64
+    %out_bool = ult __manually_drop_u64_lt_left_%out_bool, __manually_drop_u64_lt_right_%out_bool
+    !__manually_drop_u64_lt_right_%out_bool
+    !__manually_drop_u64_lt_left_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_LT.
+[MACRO] MANUALLY_DROP_LT %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_LT %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_LE %out_bool, %left_slot, %right_slot
+    __manually_drop_u64_le_left_%out_bool = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_le_right_%out_bool = load %right_slot+ManuallyDropU64_value as u64
+    %out_bool = ule __manually_drop_u64_le_left_%out_bool, __manually_drop_u64_le_right_%out_bool
+    !__manually_drop_u64_le_right_%out_bool
+    !__manually_drop_u64_le_left_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_LE.
+[MACRO] MANUALLY_DROP_LE %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_LE %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_GT %out_bool, %left_slot, %right_slot
+    __manually_drop_u64_gt_left_%out_bool = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_gt_right_%out_bool = load %right_slot+ManuallyDropU64_value as u64
+    %out_bool = ugt __manually_drop_u64_gt_left_%out_bool, __manually_drop_u64_gt_right_%out_bool
+    !__manually_drop_u64_gt_right_%out_bool
+    !__manually_drop_u64_gt_left_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_GT.
+[MACRO] MANUALLY_DROP_GT %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_GT %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MANUALLY_DROP_U64_GE %out_bool, %left_slot, %right_slot
+    __manually_drop_u64_ge_left_%out_bool = load %left_slot+ManuallyDropU64_value as u64
+    __manually_drop_u64_ge_right_%out_bool = load %right_slot+ManuallyDropU64_value as u64
+    %out_bool = uge __manually_drop_u64_ge_left_%out_bool, __manually_drop_u64_ge_right_%out_bool
+    !__manually_drop_u64_ge_right_%out_bool
+    !__manually_drop_u64_ge_left_%out_bool
+[END_MACRO]
+
+// Rust method-name alias over MANUALLY_DROP_U64_GE.
+[MACRO] MANUALLY_DROP_GE %out_bool, %left_slot, %right_slot
+    EXPAND MANUALLY_DROP_U64_GE %out_bool, %left_slot, %right_slot
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_F32 %out_size
+    %out_size = add 0, MEM_SIZE_F32
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_F32 %out_align
+    %out_align = add 0, MEM_ALIGN_F32
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_F64 %out_size
+    %out_size = add 0, MEM_SIZE_F64
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_F64 %out_align
+    %out_align = add 0, MEM_ALIGN_F64
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_PTR %out_size
+    %out_size = add 0, MEM_SIZE_PTR
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_PTR %out_align
+    %out_align = add 0, MEM_ALIGN_PTR
+[END_MACRO]
+
+[MACRO] MEM_SIZE_OF_CHAR %out_size
+    %out_size = add 0, MEM_SIZE_CHAR
+[END_MACRO]
+
+[MACRO] MEM_ALIGN_OF_CHAR %out_align
+    %out_align = add 0, MEM_ALIGN_CHAR
+[END_MACRO]