wasmtime 21.0.1 → 22.0.0

data/ext/cargo-vendor/cranelift-codegen-0.109.0/src/prelude.isle

@@ -0,0 +1,664 @@
+;; This is a prelude of standard definitions for ISLE, the instruction-selector
+;; DSL, as we use it bound to our interfaces.
+;;
+;; Note that all `extern` functions here are typically defined in the
+;; `isle_prelude_methods` macro defined in `src/isa/isle.rs`
+
+;;;; Primitive and External Types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; `()`
+(type Unit (primitive Unit))
+
+(decl pure unit () Unit)
+(extern constructor unit unit)
+
+(type bool (primitive bool))
+(extern const $true bool)
+(extern const $false bool)
+
+(type u8 (primitive u8))
+(type u16 (primitive u16))
+(type u32 (primitive u32))
+(type u64 (primitive u64))
+(type u128 (primitive u128))
+(type usize (primitive usize))
+
+(type i8 (primitive i8))
+(type i16 (primitive i16))
+(type i32 (primitive i32))
+(type i64 (primitive i64))
+(type i128 (primitive i128))
+(type isize (primitive isize))
+
+;; `cranelift-entity`-based identifiers.
+(type Type (primitive Type))
+(type Value (primitive Value))
+(type ValueList (primitive ValueList))
+(type BlockCall (primitive BlockCall))
+
+;; ISLE representation of `&[Value]`.
+(type ValueSlice (primitive ValueSlice))
+
+;; Extract the type of a `Value`.
+(decl value_type (Type) Value)
+(extern extractor infallible value_type value_type)
+
+;; Extractor that matches a `u32` only if non-negative.
+(decl u32_nonnegative (u32) u32)
+(extern extractor u32_nonnegative u32_nonnegative)
+
+;; Extractor that pulls apart an Offset32 into a i32 with the raw
+;; signed-32-bit twos-complement bits.
+(decl offset32 (i32) Offset32)
+(extern extractor infallible offset32 offset32)
+
+;; Pure/fallible constructor that tests if one u32 is less than or
+;; equal to another.
+(decl pure partial u32_lteq (u32 u32) Unit)
+(extern constructor u32_lteq u32_lteq)
+
+;; Pure/fallible constructor that tests if one u8 is less than or
+;; equal to another.
+(decl pure partial u8_lteq (u8 u8) Unit)
+(extern constructor u8_lteq u8_lteq)
+
+;; Pure/fallible constructor that tests if one u8 is strictly less
+;;  than another.
+(decl pure partial u8_lt (u8 u8) Unit)
+(extern constructor u8_lt u8_lt)
+
+;;;; Primitive Type Conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl pure u8_as_i8 (u8) i8)
+(extern constructor u8_as_i8 u8_as_i8)
+
+(decl pure u8_as_u32 (u8) u32)
+(extern constructor u8_as_u32 u8_as_u32)
+(convert u8 u32 u8_as_u32)
+
+(decl pure u8_as_u64 (u8) u64)
+(extern constructor u8_as_u64 u8_as_u64)
+(convert u8 u64 u8_as_u64)
+
+(decl pure u16_as_u64 (u16) u64)
+(extern constructor u16_as_u64 u16_as_u64)
+(convert u16 u64 u16_as_u64)
+
+(decl pure u32_as_u64 (u32) u64)
+(extern constructor u32_as_u64 u32_as_u64)
+(convert u32 u64 u32_as_u64)
+
+(decl pure i32_as_i64 (i32) i64)
+(extern constructor i32_as_i64 i32_as_i64)
+(convert i32 i64 i32_as_i64)
+
+(decl pure i64_as_u64 (i64) u64)
+(extern constructor i64_as_u64 i64_as_u64)
+
+(decl pure i64_neg (i64) i64)
+(extern constructor i64_neg i64_neg)
+
+(decl pure i8_neg (i8) i8)
+(extern constructor i8_neg i8_neg)
+
+(decl u128_as_u64 (u64) u128)
+(extern extractor u128_as_u64 u128_as_u64)
+
+(decl u64_as_u32 (u32) u64)
+(extern extractor u64_as_u32 u64_as_u32)
+
+(decl pure u64_as_i32 (u64) i32)
+(extern constructor u64_as_i32 u64_as_i32)
+
+;;;; Primitive Arithmetic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl pure u8_and (u8 u8) u8)
+(extern constructor u8_and u8_and)
+
+(decl pure u8_shl (u8 u8) u8)
+(extern constructor u8_shl u8_shl)
+
+(decl pure u8_shr (u8 u8) u8)
+(extern constructor u8_shr u8_shr)
+
+(decl pure u8_sub (u8 u8) u8)
+(extern constructor u8_sub u8_sub)
+
+(decl pure u32_add (u32 u32) u32)
+(extern constructor u32_add u32_add)
+
+(decl pure u32_sub (u32 u32) u32)
+(extern constructor u32_sub u32_sub)
+
+(decl pure u32_and (u32 u32) u32)
+(extern constructor u32_and u32_and)
+
+(decl pure u32_shl (u32 u32) u32)
+(extern constructor u32_shl u32_shl)
+
+;; Pure/fallible constructor that tries to add two `u32`s, interpreted
+;; as signed values, and fails to match on overflow.
+(decl pure partial s32_add_fallible (i32 i32) i32)
+(extern constructor s32_add_fallible s32_add_fallible)
+
+(decl pure u64_add (u64 u64) u64)
+(extern constructor u64_add u64_add)
+
+(decl pure u64_sub (u64 u64) u64)
+(extern constructor u64_sub u64_sub)
+
+(decl pure u64_mul (u64 u64) u64)
+(extern constructor u64_mul u64_mul)
+
+(decl pure partial u64_sdiv (u64 u64) u64)
+(extern constructor u64_sdiv u64_sdiv)
+
+(decl pure partial u64_udiv (u64 u64) u64)
+(extern constructor u64_udiv u64_udiv)
+
+(decl pure u64_and (u64 u64) u64)
+(extern constructor u64_and u64_and)
+
+(decl pure u64_or (u64 u64) u64)
+(extern constructor u64_or u64_or)
+
+(decl pure u64_xor (u64 u64) u64)
+(extern constructor u64_xor u64_xor)
+
+(decl pure u64_shl (u64 u64) u64)
+(extern constructor u64_shl u64_shl)
+
+(decl pure imm64_shl (Type Imm64 Imm64) Imm64)
+(extern constructor imm64_shl imm64_shl)
+
+(decl pure imm64_ushr (Type Imm64 Imm64) Imm64)
+(extern constructor imm64_ushr imm64_ushr)
+
+(decl pure imm64_sshr (Type Imm64 Imm64) Imm64)
+(extern constructor imm64_sshr imm64_sshr)
+
+(decl pure u64_not (u64) u64)
+(extern constructor u64_not u64_not)
+
+(decl pure u64_eq (u64 u64) bool)
+(extern constructor u64_eq u64_eq)
+
+(decl pure u64_le (u64 u64) bool)
+(extern constructor u64_le u64_le)
+
+(decl pure u64_lt (u64 u64) bool)
+(extern constructor u64_lt u64_lt)
+
+(decl pure i64_shr (i64 i64) i64)
+(extern constructor i64_shr i64_shr)
+
+(decl pure i64_ctz (i64) i64)
+(extern constructor i64_ctz i64_ctz)
+
+;; Sign extends a u64 from ty bits up to 64bits
+(decl pure i64_sextend_u64 (Type u64) i64)
+(extern constructor i64_sextend_u64 i64_sextend_u64)
+
+(decl pure i64_sextend_imm64 (Type Imm64) i64)
+(extern constructor i64_sextend_imm64 i64_sextend_imm64)
+
+(decl pure u64_uextend_imm64 (Type Imm64) u64)
+(extern constructor u64_uextend_imm64 u64_uextend_imm64)
+
+(decl pure imm64_icmp (Type IntCC Imm64 Imm64) Imm64)
+(extern constructor imm64_icmp imm64_icmp)
+
+(decl u64_is_zero (bool) u64)
+(extern extractor infallible u64_is_zero u64_is_zero)
+
+(decl i64_is_zero (bool) i64)
+(extern extractor infallible i64_is_zero i64_is_zero)
+
+(decl u64_zero () u64)
+(extractor (u64_zero) (u64_is_zero $true))
+
+(decl u64_nonzero (u64) u64)
+(extractor (u64_nonzero x) (and (u64_is_zero $false) x))
+
+(decl i64_nonzero (i64) i64)
+(extractor (i64_nonzero x) (and (i64_is_zero $false) x))
+
+(decl pure u64_is_odd (u64) bool)
+(extern constructor u64_is_odd u64_is_odd)
+
+;; Each of these extractors tests whether the upper half of the input equals the
+;; lower half of the input
+(decl u128_replicated_u64 (u64) u128)
+(extern extractor u128_replicated_u64 u128_replicated_u64)
+(decl u64_replicated_u32 (u64) u64)
+(extern extractor u64_replicated_u32 u64_replicated_u32)
+(decl u32_replicated_u16 (u64) u64)
+(extern extractor u32_replicated_u16 u32_replicated_u16)
+(decl u16_replicated_u8 (u8) u64)
+(extern extractor u16_replicated_u8 u16_replicated_u8)
+
+;; Floating point operations
+
+(decl pure f32_neg (Ieee32) Ieee32)
+(extern constructor f32_neg f32_neg)
+(decl pure f32_abs (Ieee32) Ieee32)
+(extern constructor f32_abs f32_abs)
+(decl pure f32_copysign (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_copysign f32_copysign)
+(decl pure f64_neg (Ieee64) Ieee64)
+(extern constructor f64_neg f64_neg)
+(decl pure f64_abs (Ieee64) Ieee64)
+(extern constructor f64_abs f64_abs)
+(decl pure f64_copysign (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_copysign f64_copysign)
+
+;;;; `cranelift_codegen::ir::Type` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(extern const $I8 Type)
+(extern const $I16 Type)
+(extern const $I32 Type)
+(extern const $I64 Type)
+(extern const $I128 Type)
+
+(extern const $R32 Type)
+(extern const $R64 Type)
+
+(extern const $F32 Type)
+(extern const $F64 Type)
+
+(extern const $I8X8 Type)
+(extern const $I8X16 Type)
+(extern const $I16X4 Type)
+(extern const $I16X8 Type)
+(extern const $I32X2 Type)
+(extern const $I32X4 Type)
+(extern const $I64X2 Type)
+
+(extern const $F32X4 Type)
+(extern const $F64X2 Type)
+
+(extern const $I32X4XN Type)
+
+;; Get the unsigned minimum value for a given type.
+;; This always zero, but is included for completeness.
+(decl pure ty_umin (Type) u64)
+(extern constructor ty_umin ty_umin)
+
+;; Get the unsigned maximum value for a given type.
+(decl pure ty_umax (Type) u64)
+(extern constructor ty_umax ty_umax)
+
+;; Get the signed minimum value for a given type.
+(decl pure ty_smin (Type) u64)
+(extern constructor ty_smin ty_smin)
+
+;; Get the signed maximum value for a given type.
+(decl pure ty_smax (Type) u64)
+(extern constructor ty_smax ty_smax)
+
+;; Get the bit width of a given type.
+(decl pure ty_bits (Type) u8)
+(extern constructor ty_bits ty_bits)
+
+;; Get the bit width of a given type.
+(decl pure ty_bits_u16 (Type) u16)
+(extern constructor ty_bits_u16 ty_bits_u16)
+
+;; Get the bit width of a given type.
+(decl pure ty_bits_u64 (Type) u64)
+(extern constructor ty_bits_u64 ty_bits_u64)
+
+;; Get a mask for the width of a given type.
+(decl pure ty_mask (Type) u64)
+(extern constructor ty_mask ty_mask)
+
+;; Get a mask that is set for each lane in a given type.
+(decl pure ty_lane_mask (Type) u64)
+(extern constructor ty_lane_mask ty_lane_mask)
+
+;; Get the number of lanes for a given type.
+(decl pure ty_lane_count (Type) u64)
+(extern constructor ty_lane_count ty_lane_count)
+
+;; Get the byte width of a given type.
+(decl pure ty_bytes (Type) u16)
+(extern constructor ty_bytes ty_bytes)
+
+;; Get the type of each lane in the given type.
+(decl pure lane_type (Type) Type)
+(extern constructor lane_type lane_type)
+
+;; Get a type with the same element type, but half the number of lanes.
+(decl pure partial ty_half_lanes (Type) Type)
+(extern constructor ty_half_lanes ty_half_lanes)
+
+;; Get a type with the same number of lanes but a lane type that is half as small.
+(decl pure partial ty_half_width (Type) Type)
+(extern constructor ty_half_width ty_half_width)
+
+;; Generate a mask for the maximum shift amount for a given type. i.e 31 for I32.
+(decl pure ty_shift_mask (Type) u64)
+(rule (ty_shift_mask ty) (u64_sub (ty_bits (lane_type ty)) 1))
+
+;; Compare two types for equality.
+(decl pure ty_equal (Type Type) bool)
+(extern constructor ty_equal ty_equal)
+
+(decl pure is_ref_type (Type) bool)
+(rule 1 (is_ref_type $R32) $true)
+(rule 1 (is_ref_type $R64) $true)
+(rule 0 (is_ref_type _) $false)
+
+;;;; `cranelift_codegen::ir::MemFlags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; `MemFlags::trusted`
+(decl pure mem_flags_trusted () MemFlags)
+(extern constructor mem_flags_trusted mem_flags_trusted)
+
+;;;; Helpers for Working with Flags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Swap args of an IntCC flag.
+(decl intcc_swap_args (IntCC) IntCC)
+(extern constructor intcc_swap_args intcc_swap_args)
+
+;; Complement an IntCC flag.
+(decl intcc_complement (IntCC) IntCC)
+(extern constructor intcc_complement intcc_complement)
+
+;; This is a direct import of `IntCC::without_equal`.
+;; Get the corresponding IntCC with the equal component removed.
+;; For conditions without a zero component, this is a no-op.
+(decl pure intcc_without_eq (IntCC) IntCC)
+(extern constructor intcc_without_eq intcc_without_eq)
+
+;; Swap args of a FloatCC flag.
+(decl floatcc_swap_args (FloatCC) FloatCC)
+(extern constructor floatcc_swap_args floatcc_swap_args)
+
+;; Complement a FloatCC flag.
+(decl floatcc_complement (FloatCC) FloatCC)
+(extern constructor floatcc_complement floatcc_complement)
+
+;; True when this FloatCC involves an unordered comparison.
+(decl pure floatcc_unordered (FloatCC) bool)
+(extern constructor floatcc_unordered floatcc_unordered)
+
+;;;; Helper Clif Extractors ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl eq (Type Value Value) Value)
+(extractor (eq ty x y) (icmp ty (IntCC.Equal) x y))
+
+(decl ne (Type Value Value) Value)
+(extractor (ne ty x y) (icmp ty (IntCC.NotEqual) x y))
+
+(decl ult (Type Value Value) Value)
+(extractor (ult ty x y) (icmp ty (IntCC.UnsignedLessThan) x y))
+
+(decl ule (Type Value Value) Value)
+(extractor (ule ty x y) (icmp ty (IntCC.UnsignedLessThanOrEqual) x y))
+
+(decl ugt (Type Value Value) Value)
+(extractor (ugt ty x y) (icmp ty (IntCC.UnsignedGreaterThan) x y))
+
+(decl uge (Type Value Value) Value)
+(extractor (uge ty x y) (icmp ty (IntCC.UnsignedGreaterThanOrEqual) x y))
+
+(decl slt (Type Value Value) Value)
+(extractor (slt ty x y) (icmp ty (IntCC.SignedLessThan) x y))
+
+(decl sle (Type Value Value) Value)
+(extractor (sle ty x y) (icmp ty (IntCC.SignedLessThanOrEqual) x y))
+
+(decl sgt (Type Value Value) Value)
+(extractor (sgt ty x y) (icmp ty (IntCC.SignedGreaterThan) x y))
+
+(decl sge (Type Value Value) Value)
+(extractor (sge ty x y) (icmp ty (IntCC.SignedGreaterThanOrEqual) x y))
+
+;; An extractor that only matches types that can fit in 16 bits.
+(decl fits_in_16 (Type) Type)
+(extern extractor fits_in_16 fits_in_16)
+
+;; An extractor that only matches types that can fit in 32 bits.
+(decl fits_in_32 (Type) Type)
+(extern extractor fits_in_32 fits_in_32)
+
+;; An extractor that only matches types that can fit in 32 bits.
+(decl lane_fits_in_32 (Type) Type)
+(extern extractor lane_fits_in_32 lane_fits_in_32)
+
+;; An extractor that only matches types that can fit in 64 bits.
+(decl fits_in_64 (Type) Type)
+(extern extractor fits_in_64 fits_in_64)
+
+;; An extractor that only matches types that fit in exactly 32 bits.
+(decl ty_32 (Type) Type)
+(extern extractor ty_32 ty_32)
+
+;; An extractor that only matches types that fit in exactly 64 bits.
+(decl ty_64 (Type) Type)
+(extern extractor ty_64 ty_64)
+
+;; A pure constructor/extractor that only matches scalar integers, and
+;; references that can fit in 64 bits.
+(decl pure partial ty_int_ref_scalar_64 (Type) Type)
+(extern constructor ty_int_ref_scalar_64 ty_int_ref_scalar_64)
+(extern extractor ty_int_ref_scalar_64 ty_int_ref_scalar_64_extract)
+
+;; An extractor that matches 32- and 64-bit types only.
+(decl ty_32_or_64 (Type) Type)
+(extern extractor ty_32_or_64 ty_32_or_64)
+
+;; An extractor that matches 8- and 16-bit types only.
+(decl ty_8_or_16 (Type) Type)
+(extern extractor ty_8_or_16 ty_8_or_16)
+
+;; An extractor that matches 16- and 32-bit types only.
+(decl ty_16_or_32 (Type) Type)
+(extern extractor ty_16_or_32 ty_16_or_32)
+
+;; An extractor that matches int types that fit in 32 bits.
+(decl int_fits_in_32 (Type) Type)
+(extern extractor int_fits_in_32 int_fits_in_32)
+
+;; An extractor that matches I64 or R64.
+(decl ty_int_ref_64 (Type) Type)
+(extern extractor ty_int_ref_64 ty_int_ref_64)
+
+;; An extractor that matches int or reference types bigger than 16 bits but at most 64 bits.
+(decl ty_int_ref_16_to_64 (Type) Type)
+(extern extractor ty_int_ref_16_to_64 ty_int_ref_16_to_64)
+
+;; An extractor that only matches integers.
+(decl ty_int (Type) Type)
+(extern extractor ty_int ty_int)
+
+;; An extractor that only matches scalar types, float or int or ref's.
+(decl ty_scalar (Type) Type)
+(extern extractor ty_scalar ty_scalar)
+
+;; An extractor that only matches scalar floating-point types--F32 or F64.
+(decl ty_scalar_float (Type) Type)
+(extern extractor ty_scalar_float ty_scalar_float)
+
+;; An extractor that matches scalar floating-point types or vector types.
+(decl ty_float_or_vec (Type) Type)
+(extern extractor ty_float_or_vec ty_float_or_vec)
+
+;; A pure constructor that only matches vector floating-point types.
+(decl pure partial ty_vector_float (Type) Type)
+(extern constructor ty_vector_float ty_vector_float)
+
+;; A pure constructor that only matches vector types with lanes which
+;; are not floating-point.
+(decl pure partial ty_vector_not_float (Type) Type)
+(extern constructor ty_vector_not_float ty_vector_not_float)
+
+;; A pure constructor/extractor that only matches 64-bit vector types.
+(decl pure partial ty_vec64 (Type) Type)
+(extern constructor ty_vec64 ty_vec64_ctor)
+(extern extractor ty_vec64 ty_vec64)
+
+;; An extractor that only matches 128-bit vector types.
+(decl ty_vec128 (Type) Type)
+(extern extractor ty_vec128 ty_vec128)
+
+;; An extractor that only matches dynamic vector types with a 64-bit
+;; base type.
+(decl ty_dyn_vec64 (Type) Type)
+(extern extractor ty_dyn_vec64 ty_dyn_vec64)
+
+;; An extractor that only matches dynamic vector types with a 128-bit
+;; base type.
+(decl ty_dyn_vec128 (Type) Type)
+(extern extractor ty_dyn_vec128 ty_dyn_vec128)
+
+;; An extractor that only matches 64-bit vector types with integer
+;; lanes (I8X8, I16X4, I32X2)
+(decl ty_vec64_int (Type) Type)
+(extern extractor ty_vec64_int ty_vec64_int)
+
+;; An extractor that only matches 128-bit vector types with integer
+;; lanes (I8X16, I16X8, I32X4, I64X2).
+(decl ty_vec128_int (Type) Type)
+(extern extractor ty_vec128_int ty_vec128_int)
+
+;; An extractor that only matches types that can be a 64-bit address.
+(decl ty_addr64 (Type) Type)
+(extern extractor ty_addr64 ty_addr64)
+
+;; A pure constructor that matches everything except vectors with size 32X2.
+(decl pure partial not_vec32x2 (Type) Type)
+(extern constructor not_vec32x2 not_vec32x2)
+
+;; An extractor that matches everything except I64X2
+(decl not_i64x2 () Type)
+(extern extractor not_i64x2 not_i64x2)
+
+;; Extract a `u8` from an `Uimm8`.
+(decl u8_from_uimm8 (u8) Uimm8)
+(extern extractor infallible u8_from_uimm8 u8_from_uimm8)
+
+;; Extract a `u64` from a `bool`.
+(decl u64_from_bool (u64) bool)
+(extern extractor infallible u64_from_bool u64_from_bool)
+
+;; Extract a `u64` from an `Imm64`.
+(decl u64_from_imm64 (u64) Imm64)
+(extern extractor infallible u64_from_imm64 u64_from_imm64)
+
+;; Extract a `u64` from an `Imm64` which is not zero.
+(decl nonzero_u64_from_imm64 (u64) Imm64)
+(extern extractor nonzero_u64_from_imm64 nonzero_u64_from_imm64)
+
+;; If the given `Imm64` is a power-of-two, extract its log2 value.
+(decl imm64_power_of_two (u64) Imm64)
+(extern extractor imm64_power_of_two imm64_power_of_two)
+
+;; Create a new Imm64.
+(decl pure imm64 (u64) Imm64)
+(extern constructor imm64 imm64)
+
+;; Create a new Imm64, masked to the width of the given type.
+(decl pure imm64_masked (Type u64) Imm64)
+(extern constructor imm64_masked imm64_masked)
+
+;; Extract a `u64` from an `Ieee32`.
+(decl u32_from_ieee32 (u32) Ieee32)
+(extern extractor infallible u32_from_ieee32 u32_from_ieee32)
+
+;; Extract a `u64` from an `Ieee64`.
+(decl u64_from_ieee64 (u64) Ieee64)
+(extern extractor infallible u64_from_ieee64 u64_from_ieee64)
+
+;; Match a multi-lane type, extracting (# bits per lane, # lanes) from the given
+;; type. Will only match when there is more than one lane.
+(decl multi_lane (u32 u32) Type)
+(extern extractor multi_lane multi_lane)
+
+;; Match a dynamic-lane type, extracting (# bits per lane) from the given
+;; type.
+(decl dynamic_lane (u32 u32) Type)
+(extern extractor dynamic_lane dynamic_lane)
+
+;; Match a dynamic-lane integer type, extracting (# bits per lane) from the given
+;; type.
+(decl dynamic_int_lane (u32) Type)
+(extern extractor dynamic_int_lane dynamic_int_lane)
+
+;; Match a dynamic-lane floating point type, extracting (# bits per lane)
+;; from the given type.
+(decl dynamic_fp_lane (u32) Type)
+(extern extractor dynamic_fp_lane dynamic_fp_lane)
+
+;; An extractor that only matches 64-bit dynamic vector types with integer
+;; lanes (I8X8XN, I16X4XN, I32X2XN)
+(decl ty_dyn64_int (Type) Type)
+(extern extractor ty_dyn64_int ty_dyn64_int)
+
+;; An extractor that only matches 128-bit dynamic vector types with integer
+;; lanes (I8X16XN, I16X8XN, I32X4XN, I64X2XN).
+(decl ty_dyn128_int (Type) Type)
+(extern extractor ty_dyn128_int ty_dyn128_int)
+
+;; Convert an `Offset32` to a primitive number.
+(decl pure offset32_to_i32 (Offset32) i32)
+(extern constructor offset32_to_i32 offset32_to_i32)
+
+;; Convert a number to an `Offset32`
+(decl pure i32_to_offset32 (i32) Offset32)
+(extern constructor i32_to_offset32 i32_to_offset32)
+
+;; This is a direct import of `IntCC::unsigned`.
+;; Get the corresponding IntCC with the signed component removed.
+;; For conditions without a signed component, this is a no-op.
+(decl pure intcc_unsigned (IntCC) IntCC)
+(extern constructor intcc_unsigned intcc_unsigned)
+
+;; Pure constructor that only matches signed integer cond codes.
+(decl pure partial signed_cond_code (IntCC) IntCC)
+(extern constructor signed_cond_code signed_cond_code)
+
+;;;; Helpers for Working with TrapCode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl pure trap_code_division_by_zero () TrapCode)
+(extern constructor trap_code_division_by_zero trap_code_division_by_zero)
+
+(decl pure trap_code_integer_overflow () TrapCode)
+(extern constructor trap_code_integer_overflow trap_code_integer_overflow)
+
+(decl pure trap_code_bad_conversion_to_integer () TrapCode)
+(extern constructor trap_code_bad_conversion_to_integer trap_code_bad_conversion_to_integer)
+
+;;;; Helpers for tail recursion loops ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; A range of integers to loop through.
+(type Range (primitive Range))
+
+;; Create a new range from `start` through `end` (exclusive).
+(decl pure range (usize usize) Range)
+(extern constructor range range)
+
+;; A view on the current state of the range.
+(type RangeView extern
+      (enum
+        (Empty)
+        (NonEmpty (index usize) (rest Range))))
+
+;; View the current state of the range.
+(decl range_view (RangeView) Range)
+(extern extractor infallible range_view range_view)
+
+;; Extractor to test whether a range is empty.
+(decl range_empty () Range)
+(extractor (range_empty) (range_view (RangeView.Empty)))
+
+;; Extractor to return the first value in the range, and a sub-range
+;; containing the remaining values.
+(decl range_unwrap (usize Range) Range)
+(extractor (range_unwrap index rest) (range_view (RangeView.NonEmpty index rest)))
+
+;;;; Automatic conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(convert Offset32 i32 offset32_to_i32)
+(convert i32 Offset32 i32_to_offset32)