vendor/cranelift-codegen/src/prelude.isle

;; 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 u32 with the raw
;; signed-32-bit twos-complement bits.
(decl offset32 (u32) 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)

;; Get a signed 32-bit immediate in an u32 from an Imm64, if possible.
(decl simm32 (u32) Imm64)
(extern extractor simm32 simm32)

;; Get an unsigned 8-bit immediate in a u8 from an Imm64, if possible.
(decl uimm8 (u8) Imm64)
(extern extractor uimm8 uimm8)

;;;; Primitive Type Conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(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)

(decl pure u32_as_u64 (u32) u64)
(extern constructor u32_as_u64 u32_as_u64)
(convert u32 u64 u32_as_u64)

(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 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 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)

;; 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 (u32 u32) u32)
(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_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 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 pure u64_is_odd (u64) bool)
(extern constructor u64_is_odd u64_is_odd)

;;;; `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)

;; Compare two types for equality.
(decl pure ty_equal (Type Type) bool)
(extern constructor ty_equal ty_equal)

;;;; `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 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Reverse an IntCC flag.
(decl intcc_reverse (IntCC) IntCC)
(extern constructor intcc_reverse intcc_reverse)

;; Invert an IntCC flag.
(decl intcc_inverse (IntCC) IntCC)
(extern constructor intcc_inverse intcc_inverse)

;; Reverse an FloatCC flag.
(decl floatcc_reverse (FloatCC) FloatCC)
(extern constructor floatcc_reverse floatcc_reverse)

;; Invert an FloatCC flag.
(decl floatcc_inverse (FloatCC) FloatCC)
(extern constructor floatcc_inverse floatcc_inverse)

;; 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 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_u32 (Offset32) u32)
(extern constructor offset32_to_u32 offset32_to_u32)

;; Convert a number to an `Offset32`
(decl pure u32_to_offset32 (u32) Offset32)
(extern constructor u32_to_offset32 u32_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 u32 offset32_to_u32)
(convert u32 Offset32 u32_to_offset32)