🥮 mooncakes.io

    machv

    Target-neutral semantic machine IR

    compiler
    machine-ir
    codegen
    jit
    Download zip
    Author
    Version
    0.12.6
    License
    Apache-2.0
    Repository
    Last updated
    24 days ago
    Downloads
    251

    #machv

    MachV provides the target-neutral semantic machine IR and the shared storage contracts used after target instruction selection.

    #Packages

    • Milky2018/machv: typed target-neutral SSA, builders, cleanup, printing, and verification.
    • Milky2018/machv/vcode: generic dense Target VCode storage parameterized by a target-owned instruction type, plus allocation, frame, and final-emission input contracts.
    • Milky2018/machv/code_object: verified, unlinked machine code plus typed relocations, traps, safepoints, roots, and unwind bytes.

    The VCode package does not define a union of AArch64 and x64 instructions. Each target supplies its own closed instruction type, while the shared package stores CFG edges, SSA values, stable instruction handles, operand constraints, soft physical-register preferences, clobbers, safepoints, and allocation edits.

    The VCode package also owns the pure call-transfer planner shared by machine targets. After allocation, targets normalize ABI register and outgoing-stack destinations into one atomic transfer request. The planner captures stack arguments before destructive register moves, resolves register cycles, protects safepoint root homes, and returns a verified ordered plan. ABI layout, frame offsets, and instruction encoding remain target-owned.

    VCode models AArch64/x64 hardware aliasing directly: scalar floating-point and SIMD values share one FpVector register bank. They can never be allocated to the same physical register as if the hardware exposed independent banks.

    #Pipeline boundary

    Target lowering consumes verified semantic MachV and produces a complete Function[TargetInst]. Register allocation reads the compact operand side tables and returns a separate Allocation; it does not rewrite Target VCode. Frame planning and emission consume the same stable instruction and program point handles.

    The aggregate target compile entry points report TargetCompileEvent boundaries around allocation, frame planning, and emission. The allocation completion event carries AllocationStatistics, including edge-transfer classification, while keeping timing and reporting policy embedding-owned.

    The public checkpoints are:

    1. selected Target VCode SSA;
    2. Target VCode plus Allocation;
    3. Target VCode, Allocation, and FrameLayout;
    4. verified unlinked code object.

    Every checkpoint returns a structured error for malformed input.

    #Embedding environment fields

    Semantic MachV keeps embedding context access explicit as EnvironmentField(field, stability). Stable means the embedding guarantees the field value is unchanged for one function invocation; Mutable does not grant that reuse permission. MilkIR owns semantic reuse before lowering; MachV preserves the remaining occurrences, and targets materialize them without a second pressure-based reuse policy. Field offsets and runtime layout remain embedding-provided ABI data.

    CallAbiElaborationError

    source
    pub suberror CallAbiElaborationError {
      InvalidInput(cause~ : MachVVerifyError)
      InvalidOutput(cause~ : MachVVerifyError)
      InvalidCall(instruction_id~ : Int, message~ : String)
    } derive(Eq, 
    Debug    )

    CallAbiElaborationError::equal

    source

    CallAbiElaborationError::not_equal

    source

    CallAbiElaborationError::output

    source
    fn CallAbiElaborationError::output(self : CallAbiElaborationError, logger : &Logger) -> Unit

    CallAbiElaborationError::to_repr

    source

    CallAbiElaborationError::to_string

    source
    fn CallAbiElaborationError::to_string(self : CallAbiElaborationError) -> String

    MachVVerifyError

    source
    pub suberror MachVVerifyError {
      EmptyFunction
      InvalidFunction(message~ : String)
      ForeignValue(value_id~ : Int)
      ForeignBlock(block_id~ : Int)
      ForeignInstruction(instruction_id~ : Int)
      ForeignStackObject(object_id~ : Int)
      InvalidStackObject(object_id~ : Int, message~ : String)
      TerminatorAlreadySet(block_id~ : Int)
      MissingTerminator(block_id~ : Int)
      EntryHasBlockParameters
      EntryHasPredecessor(block_id~ : Int)
      UnreachableBlock(block_id~ : Int)
      InvalidValueDefinition(value_id~ : Int)
      DuplicateValueDefinition(value_id~ : Int)
      DuplicateInstructionMembership(instruction_id~ : Int)
      OrphanInstruction(instruction_id~ : Int)
      RemovedValueUse(value_id~ : Int)
      UseBeforeDefinition(value_id~ : Int, block_id~ : Int, instruction_id~ : Int)
      NonDominatingUse(value_id~ : Int, defining_block_id~ : Int, use_block_id~ : Int)
      InvalidOperation(block_id~ : Int, message~ : String)
      InvalidInstruction(block_id~ : Int, instruction_id~ : Int, message~ : String)
      InvalidEdge(block_id~ : Int, target_id~ : Int, message~ : String)
      InvalidTerminator(block_id~ : Int, message~ : String)
      InvalidSafepoint(block_id~ : Int, message~ : String)
      MissingGcRoot(block_id~ : Int, instruction_id~ : Int, value_id~ : Int)
      InvalidMetadata(block_id~ : Int, message~ : String)
    } derive(Eq, 
    Debug    )

    Deterministic structured failures from the semantic MachV checkpoint.

    MachVVerifyError::equal

    source

    MachVVerifyError::not_equal

    source
    fn MachVVerifyError::not_equal(x : MachVVerifyError, y : MachVVerifyError) -> Bool

    MachVVerifyError::output

    source
    fn MachVVerifyError::output(self : MachVVerifyError, logger : &Logger) -> Unit

    MachVVerifyError::to_repr

    source

    MachVVerifyError::to_string

    source
    fn MachVVerifyError::to_string(self : MachVVerifyError) -> String

    AccessWidth

    source
    pub(all) enum AccessWidth {
      W8
      W16
      W32
      W64
      W128
    } derive(Eq, Hash, 
    Debug    )

    AccessWidth::equal

    source
    fn AccessWidth::equal(AccessWidth, AccessWidth) -> Bool

    AccessWidth::hash

    source
    fn AccessWidth::hash(self : AccessWidth) -> Int

    AccessWidth::hash_combine

    source
    fn AccessWidth::hash_combine(AccessWidth, Hasher) -> Unit

    AccessWidth::not_equal

    source
    fn AccessWidth::not_equal(x : AccessWidth, y : AccessWidth) -> Bool

    AccessWidth::to_repr

    source

    AtomicRmwOp

    source
    pub(all) enum AtomicRmwOp {
      Add
      Sub
      And
      Or
      Xor
      Exchange
    } derive(Eq, Hash, 
    Debug    )

    AtomicRmwOp::equal

    source
    fn AtomicRmwOp::equal(AtomicRmwOp, AtomicRmwOp) -> Bool

    AtomicRmwOp::hash

    source
    fn AtomicRmwOp::hash(self : AtomicRmwOp) -> Int

    AtomicRmwOp::hash_combine

    source
    fn AtomicRmwOp::hash_combine(AtomicRmwOp, Hasher) -> Unit

    AtomicRmwOp::not_equal

    source
    fn AtomicRmwOp::not_equal(x : AtomicRmwOp, y : AtomicRmwOp) -> Bool

    AtomicRmwOp::to_repr

    source

    AtomicSpec

    source
    pub struct AtomicSpec {
      width : AccessWidth
      value_type : ValueType
      offset : UInt64
      endianness : Endianness
      trap : TrapReason?
    } derive(Eq, Hash, 
    Debug    )

    A sequentially consistent atomic memory access. Weaker memory orders are not part of the current semantic MachV contract.

    AtomicSpec::equal

    source
    fn AtomicSpec::equal(AtomicSpec, AtomicSpec) -> Bool

    AtomicSpec::hash

    source
    fn AtomicSpec::hash(self : AtomicSpec) -> Int

    AtomicSpec::hash_combine

    source
    fn AtomicSpec::hash_combine(AtomicSpec, Hasher) -> Unit

    AtomicSpec::new

    source
    fn AtomicSpec::new(width : AccessWidth, value_type : ValueType, offset : UInt64, endianness : Endianness, trap : TrapReason?) -> AtomicSpec

    AtomicSpec::not_equal

    source
    fn AtomicSpec::not_equal(x : AtomicSpec, y : AtomicSpec) -> Bool

    AtomicSpec::to_repr

    source

    Block

    source
    pub struct Block {
      // private fields
    }

    Opaque function-owned basic-block handle.
    impl Eq for Block
    impl Hash for Block
    impl Debug for Block

    Block::equal

    source
    fn Block::equal(self : Block, other : Block) -> Bool

    Block::hash

    source
    fn Block::hash(self : Block) -> Int

    Block::hash_combine

    source
    fn Block::hash_combine(self : Block, hasher : Hasher) -> Unit

    Block::not_equal

    source
    fn Block::not_equal(x : Block, y : Block) -> Bool

    Block::to_repr

    source

    CallAbiElaboration

    source
    pub struct CallAbiElaboration {
      // private fields
    }

    A constrained, target-neutral call-site ABI transformation.

    CallAbiElaboration::new

    source
    fn CallAbiElaboration::new(root_scope? : CallerRootScopeAbi, hidden_safepoints? : Array[HiddenSafepointAbi]) -> CallAbiElaboration

    CallBehavior

    source
    pub struct CallBehavior {
      memory : MemoryEffect
      may_trap : Bool
      may_unwind : Bool
      gc_safepoint : Bool
      cancellation_safepoint : Bool
      returns_twice : Bool
    } derive(Eq, Hash, 
    Debug    )

    Explicit call behavior. Protocol and callee identity never imply effects.

    CallBehavior::conservative

    source
    fn CallBehavior::conservative() -> CallBehavior

    CallBehavior::equal

    source

    CallBehavior::hash

    source
    fn CallBehavior::hash(self : CallBehavior) -> Int

    CallBehavior::hash_combine

    source
    fn CallBehavior::hash_combine(CallBehavior, Hasher) -> Unit

    CallBehavior::new

    source
    fn CallBehavior::new(memory : MemoryEffect, may_trap : Bool, may_unwind : Bool, gc_safepoint : Bool, cancellation_safepoint : Bool, returns_twice? : Bool) -> CallBehavior

    CallBehavior::not_equal

    source
    fn CallBehavior::not_equal(x : CallBehavior, y : CallBehavior) -> Bool

    CallBehavior::semantics

    source

    CallBehavior::to_repr

    source

    CallProtocol

    source
    pub(all) enum CallProtocol {
      Internal
      Platform
    } derive(Eq, Hash, 
    Debug    )

    CallProtocol::equal

    source

    CallProtocol::hash

    source
    fn CallProtocol::hash(self : CallProtocol) -> Int

    CallProtocol::hash_combine

    source
    fn CallProtocol::hash_combine(CallProtocol, Hasher) -> Unit

    CallProtocol::not_equal

    source
    fn CallProtocol::not_equal(x : CallProtocol, y : CallProtocol) -> Bool

    CallProtocol::to_repr

    source

    Callee

    source
    pub(all) enum Callee {
      Internal(CodeSymbol)
      External(ExternalSymbol)
      Indirect
    } derive(Eq, Hash, 
    Debug    )

    Callee::equal

    source
    fn Callee::equal(Callee, Callee) -> Bool

    Callee::hash

    source
    fn Callee::hash(self : Callee) -> Int

    Callee::hash_combine

    source
    fn Callee::hash_combine(Callee, Hasher) -> Unit

    Callee::not_equal

    source
    fn Callee::not_equal(x : Callee, y : Callee) -> Bool

    Callee::to_repr

    source

    CallerRootScopeAbi

    source
    pub struct CallerRootScopeAbi {
      // private fields
    }

    Runtime calls used to make caller-owned GC roots visible while a call runs.

    CallerRootScopeAbi::new

    source
    fn CallerRootScopeAbi::new(push_symbol : ExternalSymbol, pop_symbol : ExternalSymbol) -> CallerRootScopeAbi

    CleanupStats

    source
    pub struct CleanupStats {
      aliases_rewritten : Int
      instructions_removed : Int
    } derive(Eq, 
    Debug    )

    CleanupStats::equal

    source

    CleanupStats::not_equal

    source
    fn CleanupStats::not_equal(x : CleanupStats, y : CleanupStats) -> Bool

    CleanupStats::to_repr

    source

    CodeSymbol

    source
    pub struct CodeSymbol {
      name : String
    } derive(Eq, Hash, 
    Debug    )

    CodeSymbol::equal

    source
    fn CodeSymbol::equal(CodeSymbol, CodeSymbol) -> Bool

    CodeSymbol::hash

    source
    fn CodeSymbol::hash(self : CodeSymbol) -> Int

    CodeSymbol::hash_combine

    source
    fn CodeSymbol::hash_combine(CodeSymbol, Hasher) -> Unit

    CodeSymbol::new

    source
    fn CodeSymbol::new(name : String) -> CodeSymbol

    CodeSymbol::not_equal

    source
    fn CodeSymbol::not_equal(x : CodeSymbol, y : CodeSymbol) -> Bool

    CodeSymbol::to_repr

    source

    ConversionMode

    source
    pub(all) enum ConversionMode {
      Trapping
      Saturating
    } derive(Eq, Hash, 
    Debug    )

    ConversionMode::equal

    source

    ConversionMode::hash

    source
    fn ConversionMode::hash(self : ConversionMode) -> Int

    ConversionMode::hash_combine

    source
    fn ConversionMode::hash_combine(ConversionMode, Hasher) -> Unit

    ConversionMode::not_equal

    source
    fn ConversionMode::not_equal(x : ConversionMode, y : ConversionMode) -> Bool

    ConversionMode::to_repr

    source

    ConversionOp

    source
    pub(all) enum ConversionOp {
      I32WrapI64
      I64ExtendI32(Signedness)
      F32DemoteF64
      F64PromoteF32
      FloatToInt(FloatType, IntegerType, Signedness, ConversionMode)
      IntToFloat(IntegerType, FloatType, Signedness)
      SignExtend(IntegerType, AccessWidth)
      Bitcast(ValueType, ValueType)
    } derive(Eq, Hash, 
    Debug    )

    ConversionOp::equal

    source

    ConversionOp::hash

    source
    fn ConversionOp::hash(self : ConversionOp) -> Int

    ConversionOp::hash_combine

    source
    fn ConversionOp::hash_combine(ConversionOp, Hasher) -> Unit

    ConversionOp::not_equal

    source
    fn ConversionOp::not_equal(x : ConversionOp, y : ConversionOp) -> Bool

    ConversionOp::to_repr

    source

    DataSymbol

    source
    pub struct DataSymbol {
      name : String
    } derive(Eq, Hash, 
    Debug    )

    DataSymbol::equal

    source
    fn DataSymbol::equal(DataSymbol, DataSymbol) -> Bool

    DataSymbol::hash

    source
    fn DataSymbol::hash(self : DataSymbol) -> Int

    DataSymbol::hash_combine

    source
    fn DataSymbol::hash_combine(DataSymbol, Hasher) -> Unit

    DataSymbol::new

    source
    fn DataSymbol::new(name : String) -> DataSymbol

    DataSymbol::not_equal

    source
    fn DataSymbol::not_equal(x : DataSymbol, y : DataSymbol) -> Bool

    DataSymbol::to_repr

    source

    Edge

    source
    pub struct Edge {
      target : Block
      arguments : Array[Value]
    } derive(Eq, 
    Debug    )

    Edge::equal

    source
    fn Edge::equal(Edge, Edge) -> Bool

    Edge::not_equal

    source
    fn Edge::not_equal(x : Edge, y : Edge) -> Bool

    Edge::to_repr

    source

    Endianness

    source
    pub(all) enum Endianness {
      Little
      Big
    } derive(Eq, Hash, 
    Debug    )

    Endianness::equal

    source
    fn Endianness::equal(Endianness, Endianness) -> Bool

    Endianness::hash

    source
    fn Endianness::hash(self : Endianness) -> Int

    Endianness::hash_combine

    source
    fn Endianness::hash_combine(Endianness, Hasher) -> Unit

    Endianness::not_equal

    source
    fn Endianness::not_equal(x : Endianness, y : Endianness) -> Bool

    Endianness::to_repr

    source

    EnvironmentField

    source
    pub struct EnvironmentField {
      name : String
      value_type : ValueType
    } derive(Eq, Hash, 
    Debug    )

    Opaque embedding-context field identity with its semantic value type.

    The identity carries no byte offset or target addressing mode. The embedding target environment resolves it during target lowering.

    EnvironmentField::equal

    source

    EnvironmentField::hash

    source
    fn EnvironmentField::hash(self : EnvironmentField) -> Int

    EnvironmentField::hash_combine

    source
    fn EnvironmentField::hash_combine(EnvironmentField, Hasher) -> Unit

    EnvironmentField::new

    source
    fn EnvironmentField::new(name : String, value_type : ValueType) -> EnvironmentField

    EnvironmentField::not_equal

    source
    fn EnvironmentField::not_equal(x : EnvironmentField, y : EnvironmentField) -> Bool

    EnvironmentField::to_repr

    source

    EnvironmentFieldStability

    source
    pub(all) enum EnvironmentFieldStability {
      Stable
      Mutable
    } derive(Eq, Hash, 
    Debug    )

    Whether an embedding context field may be reused during one function invocation.

    Stable grants reuse permission for the invocation. Mutable requires each operation to observe the current field value. Target lowering may rematerialize either form.

    EnvironmentFieldStability::equal

    source

    EnvironmentFieldStability::hash

    source

    EnvironmentFieldStability::hash_combine

    source

    EnvironmentFieldStability::not_equal

    source

    EnvironmentFieldStability::to_repr

    source

    ExternalSymbol

    source
    pub struct ExternalSymbol {
      name : String
    } derive(Eq, Hash, 
    Debug    )

    ExternalSymbol::equal

    source

    ExternalSymbol::hash

    source
    fn ExternalSymbol::hash(self : ExternalSymbol) -> Int

    ExternalSymbol::hash_combine

    source
    fn ExternalSymbol::hash_combine(ExternalSymbol, Hasher) -> Unit

    ExternalSymbol::new

    source
    fn ExternalSymbol::new(name : String) -> ExternalSymbol

    ExternalSymbol::not_equal

    source
    fn ExternalSymbol::not_equal(x : ExternalSymbol, y : ExternalSymbol) -> Bool

    ExternalSymbol::to_repr

    source

    FloatBinaryOp

    source
    pub(all) enum FloatBinaryOp {
      Add
      Sub
      Mul
      Div
      Min
      Max
      CopySign
    } derive(Eq, Hash, 
    Debug    )

    FloatBinaryOp::equal

    source

    FloatBinaryOp::hash

    source
    fn FloatBinaryOp::hash(self : FloatBinaryOp) -> Int

    FloatBinaryOp::hash_combine

    source
    fn FloatBinaryOp::hash_combine(FloatBinaryOp, Hasher) -> Unit

    FloatBinaryOp::not_equal

    source
    fn FloatBinaryOp::not_equal(x : FloatBinaryOp, y : FloatBinaryOp) -> Bool

    FloatBinaryOp::to_repr

    source

    FloatComparison

    source
    pub(all) enum FloatComparison {
      Equal
      NotEqual
      LessThan
      LessOrEqual
      GreaterThan
      GreaterOrEqual
      Ordered
      Unordered
    } derive(Eq, Hash, 
    Debug    )

    FloatComparison::equal

    source

    FloatComparison::hash

    source
    fn FloatComparison::hash(self : FloatComparison) -> Int

    FloatComparison::hash_combine

    source
    fn FloatComparison::hash_combine(FloatComparison, Hasher) -> Unit

    FloatComparison::not_equal

    source
    fn FloatComparison::not_equal(x : FloatComparison, y : FloatComparison) -> Bool

    FloatComparison::to_repr

    source

    FloatTernaryOp

    source
    pub(all) enum FloatTernaryOp {
      FusedMultiplyAdd
      FusedNegatedMultiplyAdd
      FusedMultiplySubtract
      FusedNegatedMultiplySubtract
    } derive(Eq, Hash, 
    Debug    )

    FloatTernaryOp::equal

    source

    FloatTernaryOp::hash

    source
    fn FloatTernaryOp::hash(self : FloatTernaryOp) -> Int

    FloatTernaryOp::hash_combine

    source
    fn FloatTernaryOp::hash_combine(FloatTernaryOp, Hasher) -> Unit

    FloatTernaryOp::not_equal

    source
    fn FloatTernaryOp::not_equal(x : FloatTernaryOp, y : FloatTernaryOp) -> Bool

    FloatTernaryOp::to_repr

    source

    FloatType

    source
    pub(all) enum FloatType {
      F32
      F64
    } derive(Eq, Hash, 
    Debug    )

    FloatType::equal

    source
    fn FloatType::equal(FloatType, FloatType) -> Bool

    FloatType::hash

    source
    fn FloatType::hash(self : FloatType) -> Int

    FloatType::hash_combine

    source
    fn FloatType::hash_combine(FloatType, Hasher) -> Unit

    FloatType::not_equal

    source
    fn FloatType::not_equal(x : FloatType, y : FloatType) -> Bool

    FloatType::to_repr

    source

    FloatUnaryOp

    source
    pub(all) enum FloatUnaryOp {
      Negate
      Absolute
      SquareRoot
      Ceil
      Floor
      Truncate
      Nearest
    } derive(Eq, Hash, 
    Debug    )

    FloatUnaryOp::equal

    source

    FloatUnaryOp::hash

    source
    fn FloatUnaryOp::hash(self : FloatUnaryOp) -> Int

    FloatUnaryOp::hash_combine

    source
    fn FloatUnaryOp::hash_combine(FloatUnaryOp, Hasher) -> Unit

    FloatUnaryOp::not_equal

    source
    fn FloatUnaryOp::not_equal(x : FloatUnaryOp, y : FloatUnaryOp) -> Bool

    FloatUnaryOp::to_repr

    source

    Function

    source
    pub struct Function {
      // private fields
    }

    A target-neutral semantic machine function.

    Storage is private and canonical. Public queries return handles or snapshots; construction and transformation go through owner-aware seams.
    impl Show for Function
    impl Debug for Function

    Function::block_count

    source
    fn Function::block_count(self : Function) -> Int

    Function::block_index

    source
    fn Function::block_index(self : Function, block : Block) -> Int?

    Function::block_instructions

    source
    fn Function::block_instructions(self : Function, block : Block) -> Array[Instruction]

    Function::block_parameters

    source
    fn Function::block_parameters(self : Function, block : Block) -> Array[Value]

    Function::block_terminator

    source
    fn Function::block_terminator(self : Function, block : Block) -> TerminatorRecord?

    Function::blocks

    source
    fn Function::blocks(self : Function) -> Array[Block]

    Function::blocks_in_cfg_order

    source
    fn Function::blocks_in_cfg_order(self : Function) -> Array[Block]

    Return reachable blocks in reverse postorder, followed by any unreachable blocks in stable storage order. Target selectors use this order so every reachable SSA definition is materialized before its dominated uses without making physical block allocation order part of the semantic contract.

    Function::elaborate_call_abi

    source
    fn Function::elaborate_call_abi(self : Function, elaboration : CallAbiElaboration) -> Function raise CallAbiElaborationError

    Apply a constrained call-site ABI transformation in place.

    Existing blocks, values, instructions, and metadata retain their identity. The transformation may insert caller-root-scope calls and may append a stack-map id operand to explicitly configured hidden safepoints. No-op functions return without changing their canonical storage.

    Function::instruction_count

    source
    fn Function::instruction_count(self : Function) -> Int

    Function::instruction_index

    source
    fn Function::instruction_index(self : Function, instruction : Instruction) -> Int?

    Function::instruction_metadata

    source
    fn Function::instruction_metadata(self : Function, instruction : Instruction) -> InstructionMetadata?

    Function::instruction_operands

    source
    fn Function::instruction_operands(self : Function, instruction : Instruction) -> Array[Value]

    Function::instruction_operation

    source
    fn Function::instruction_operation(self : Function, instruction : Instruction) -> Operation?

    Function::instruction_results

    source
    fn Function::instruction_results(self : Function, instruction : Instruction) -> Array[Value]

    Function::name

    source
    fn Function::name(self : Function) -> String

    Function::output

    source
    fn Function::output(self : Function, logger : &Logger) -> Unit

    Function::parameters

    source
    fn Function::parameters(self : Function) -> Array[Value]

    Function::print

    source
    fn Function::print(self : Function) -> String

    Render the complete semantic function in a stable target-neutral form.

    Function::protocol

    source
    fn Function::protocol(self : Function) -> CallProtocol

    Function::require_verified

    source
    fn Function::require_verified(self : Function) -> Unit raise MachVVerifyError

    Require the canonical function state established by its last verifier.

    Public construction and transformation seams finish by verifying. If a package-internal producer has not done so, this falls back to full verification instead of trusting construction history.

    Function::run_mandatory_cleanup

    source
    fn Function::run_mandatory_cleanup(self : Function) -> CleanupStats raise MachVVerifyError

    Mandatory target-neutral late cleanup. It performs no target or ABI query: visible aliases are canonicalized and unused pure non-trapping operations are removed. Observable effects, traps, calls, and safepoints are retained.

    Function::signature

    source
    fn Function::signature(self : Function) -> Signature

    Function::stack_object_alignment

    source
    fn Function::stack_object_alignment(self : Function, object : StackObject) -> Int?

    Function::stack_object_size

    source
    fn Function::stack_object_size(self : Function, object : StackObject) -> Int?

    Function::stack_objects

    source
    fn Function::stack_objects(self : Function) -> Array[StackObject]

    Function::to_repr

    source

    Function::to_string

    source
    fn Function::to_string(self : Function) -> String

    Function::value_count

    source
    fn Function::value_count(self : Function) -> Int

    Function::value_index

    source
    fn Function::value_index(self : Function, value : Value) -> Int?

    Function::value_type

    source
    fn Function::value_type(self : Function, value : Value) -> ValueType?

    Function::verify

    source
    fn Function::verify(self : Function) -> Unit raise MachVVerifyError

    Verify the complete target-neutral MachV checkpoint without consulting a target, ABI, construction history, or mutable validator callback.

    FunctionBuilder

    source
    pub struct FunctionBuilder {
      // private fields
    }

    Owner-aware construction seam for semantic MachV functions.

    FunctionBuilder::block_parameters

    source
    fn FunctionBuilder::block_parameters(self : FunctionBuilder, block : Block) -> Array[Value]

    FunctionBuilder::branch

    source
    fn FunctionBuilder::branch(self : FunctionBuilder, condition : Value, true_target : Block, true_arguments : Array[Value], false_target : Block, false_arguments : Array[Value]) -> Unit

    FunctionBuilder::create_block

    source
    fn FunctionBuilder::create_block(self : FunctionBuilder, parameter_types : Array[ValueType]) -> Block

    FunctionBuilder::create_stack_object

    source
    fn FunctionBuilder::create_stack_object(self : FunctionBuilder, size : Int, alignment : Int) -> StackObject

    FunctionBuilder::current_block

    source
    fn FunctionBuilder::current_block(self : FunctionBuilder) -> Block

    FunctionBuilder::emit

    source
    fn FunctionBuilder::emit(self : FunctionBuilder, operation : Operation, operands : Array[Value], result_types : Array[ValueType]) -> Array[Value]

    Append one parameterized semantic operation after validating its local ownership and typed operation contract.

    FunctionBuilder::emit_with_metadata

    source
    fn FunctionBuilder::emit_with_metadata(self : FunctionBuilder, operation : Operation, operands : Array[Value], result_types : Array[ValueType], metadata : InstructionMetadata) -> Array[Value]

    FunctionBuilder::entry_block

    source
    fn FunctionBuilder::entry_block(self : FunctionBuilder) -> Block

    FunctionBuilder::finish

    source

    Verify the constructed function, run mandatory target-neutral cleanup, and verify the resulting function again.

    FunctionBuilder::jump

    source
    fn FunctionBuilder::jump(self : FunctionBuilder, target : Block, arguments : Array[Value]) -> Unit

    FunctionBuilder::new

    source
    fn FunctionBuilder::new(name : String, protocol : CallProtocol, params : Array[ValueType], results : Array[ValueType]) -> FunctionBuilder

    FunctionBuilder::noreturn_call

    source
    fn FunctionBuilder::noreturn_call(self : FunctionBuilder, call : SemanticCall, operands : Array[Value]) -> Unit

    FunctionBuilder::noreturn_call_with_metadata

    source
    fn FunctionBuilder::noreturn_call_with_metadata(self : FunctionBuilder, call : SemanticCall, operands : Array[Value], metadata : TerminatorMetadata) -> Unit

    FunctionBuilder::parameters

    source
    fn FunctionBuilder::parameters(self : FunctionBuilder) -> Array[Value]

    FunctionBuilder::return_

    source
    fn FunctionBuilder::return_(self : FunctionBuilder, values : Array[Value]) -> Unit

    FunctionBuilder::set_terminator_source

    source
    fn FunctionBuilder::set_terminator_source(self : FunctionBuilder, source : SourceLocation) -> Unit

    Attach a source location to the current block terminator without exposing mutable terminator storage.

    FunctionBuilder::switch

    source
    fn FunctionBuilder::switch(self : FunctionBuilder, index : Value, cases : Array[(UInt64, Block, Array[Value])], default_target : Block, default_arguments : Array[Value]) -> Unit

    FunctionBuilder::switch_to_block

    source
    fn FunctionBuilder::switch_to_block(self : FunctionBuilder, block : Block) -> Unit

    FunctionBuilder::tail_call

    source
    fn FunctionBuilder::tail_call(self : FunctionBuilder, call : SemanticCall, operands : Array[Value]) -> Unit

    FunctionBuilder::tail_call_with_metadata

    source
    fn FunctionBuilder::tail_call_with_metadata(self : FunctionBuilder, call : SemanticCall, operands : Array[Value], metadata : TerminatorMetadata) -> Unit

    FunctionBuilder::trap

    source
    fn FunctionBuilder::trap(self : FunctionBuilder, reason : TrapReason) -> Unit

    HiddenSafepointAbi

    source
    pub struct HiddenSafepointAbi {
      // private fields
    }

    One external call whose runtime ABI requires an explicit stack-map id.

    HiddenSafepointAbi::new

    source

    Instruction

    source
    pub struct Instruction {
      // private fields
    }

    Opaque function-owned instruction handle.
    impl Eq for Instruction
    impl Hash for Instruction

    Instruction::equal

    source
    fn Instruction::equal(self : Instruction, other : Instruction) -> Bool

    Instruction::hash

    source
    fn Instruction::hash(self : Instruction) -> Int

    Instruction::hash_combine

    source
    fn Instruction::hash_combine(self : Instruction, hasher : Hasher) -> Unit

    Instruction::not_equal

    source
    fn Instruction::not_equal(x : Instruction, y : Instruction) -> Bool

    Instruction::to_repr

    source

    InstructionMetadata

    source
    pub struct InstructionMetadata {
      source : SourceLocation?
      live_gc_roots : Array[Value]
      stack_map : StackMapMetadata?
    } derive(Eq, 
    Debug    )

    InstructionMetadata::empty

    source

    InstructionMetadata::equal

    source

    InstructionMetadata::new

    source
    fn InstructionMetadata::new(source : SourceLocation?, live_gc_roots : Array[Value], stack_map? : StackMapMetadata) -> InstructionMetadata

    InstructionMetadata::not_equal

    source

    InstructionMetadata::to_repr

    source

    IntBinaryOp

    source
    pub(all) enum IntBinaryOp {
      Add
      Sub
      Mul
      SignedDiv
      UnsignedDiv
      SignedRem
      UnsignedRem
      And
      Or
      Xor
      ShiftLeft
      SignedShiftRight
      UnsignedShiftRight
      RotateLeft
      RotateRight
    } derive(Eq, Hash, 
    Debug    )

    IntBinaryOp::equal

    source
    fn IntBinaryOp::equal(IntBinaryOp, IntBinaryOp) -> Bool

    IntBinaryOp::hash

    source
    fn IntBinaryOp::hash(self : IntBinaryOp) -> Int

    IntBinaryOp::hash_combine

    source
    fn IntBinaryOp::hash_combine(IntBinaryOp, Hasher) -> Unit

    IntBinaryOp::not_equal

    source
    fn IntBinaryOp::not_equal(x : IntBinaryOp, y : IntBinaryOp) -> Bool

    IntBinaryOp::to_repr

    source

    IntComparison

    source
    pub(all) enum IntComparison {
      Equal
      NotEqual
      SignedLessThan
      SignedLessOrEqual
      SignedGreaterThan
      SignedGreaterOrEqual
      UnsignedLessThan
      UnsignedLessOrEqual
      UnsignedGreaterThan
      UnsignedGreaterOrEqual
    } derive(Eq, Hash, 
    Debug    )

    IntComparison::equal

    source

    IntComparison::hash

    source
    fn IntComparison::hash(self : IntComparison) -> Int

    IntComparison::hash_combine

    source
    fn IntComparison::hash_combine(IntComparison, Hasher) -> Unit

    IntComparison::not_equal

    source
    fn IntComparison::not_equal(x : IntComparison, y : IntComparison) -> Bool

    IntComparison::to_repr

    source

    IntOverflowOp

    source
    pub(all) enum IntOverflowOp {
      Add(Signedness)
      Sub(Signedness)
      Mul(Signedness)
    } derive(Eq, Hash, 
    Debug    )

    IntOverflowOp::equal

    source

    IntOverflowOp::hash

    source
    fn IntOverflowOp::hash(self : IntOverflowOp) -> Int

    IntOverflowOp::hash_combine

    source
    fn IntOverflowOp::hash_combine(IntOverflowOp, Hasher) -> Unit

    IntOverflowOp::not_equal

    source
    fn IntOverflowOp::not_equal(x : IntOverflowOp, y : IntOverflowOp) -> Bool

    IntOverflowOp::to_repr

    source

    IntUnaryOp

    source
    pub(all) enum IntUnaryOp {
      Not
      CountLeadingZeros
      CountTrailingZeros
      PopulationCount
    } derive(Eq, Hash, 
    Debug    )

    IntUnaryOp::equal

    source
    fn IntUnaryOp::equal(IntUnaryOp, IntUnaryOp) -> Bool

    IntUnaryOp::hash

    source
    fn IntUnaryOp::hash(self : IntUnaryOp) -> Int

    IntUnaryOp::hash_combine

    source
    fn IntUnaryOp::hash_combine(IntUnaryOp, Hasher) -> Unit

    IntUnaryOp::not_equal

    source
    fn IntUnaryOp::not_equal(x : IntUnaryOp, y : IntUnaryOp) -> Bool

    IntUnaryOp::to_repr

    source

    IntegerType

    source
    pub(all) enum IntegerType {
      I32
      I64
    } derive(Eq, Hash, 
    Debug    )

    IntegerType::equal

    source
    fn IntegerType::equal(IntegerType, IntegerType) -> Bool

    IntegerType::hash

    source
    fn IntegerType::hash(self : IntegerType) -> Int

    IntegerType::hash_combine

    source
    fn IntegerType::hash_combine(IntegerType, Hasher) -> Unit

    IntegerType::not_equal

    source
    fn IntegerType::not_equal(x : IntegerType, y : IntegerType) -> Bool

    IntegerType::to_repr

    source

    LoadExtension

    source
    pub(all) enum LoadExtension {
      None
      Signed
      Unsigned
    } derive(Eq, Hash, 
    Debug    )

    LoadExtension::equal

    source

    LoadExtension::hash

    source
    fn LoadExtension::hash(self : LoadExtension) -> Int

    LoadExtension::hash_combine

    source
    fn LoadExtension::hash_combine(LoadExtension, Hasher) -> Unit

    LoadExtension::not_equal

    source
    fn LoadExtension::not_equal(x : LoadExtension, y : LoadExtension) -> Bool

    LoadExtension::to_repr

    source

    LoadSpec

    source
    pub struct LoadSpec {
      width : AccessWidth
      extension : LoadExtension
      result_type : ValueType
      offset : UInt64
      endianness : Endianness
      trap : TrapReason?
    } derive(Eq, Hash, 
    Debug    )

    LoadSpec::equal

    source
    fn LoadSpec::equal(LoadSpec, LoadSpec) -> Bool

    LoadSpec::hash

    source
    fn LoadSpec::hash(self : LoadSpec) -> Int

    LoadSpec::hash_combine

    source
    fn LoadSpec::hash_combine(LoadSpec, Hasher) -> Unit

    LoadSpec::new

    source
    fn LoadSpec::new(width : AccessWidth, extension : LoadExtension, result_type : ValueType, offset : UInt64, endianness : Endianness, trap : TrapReason?) -> LoadSpec

    LoadSpec::not_equal

    source
    fn LoadSpec::not_equal(x : LoadSpec, y : LoadSpec) -> Bool

    LoadSpec::to_repr

    source

    MemoryEffect

    source
    pub(all) enum MemoryEffect {
      None
      Read
      Write
      ReadWrite
    } derive(Eq, Hash, 
    Debug    )

    MemoryEffect::equal

    source

    MemoryEffect::hash

    source
    fn MemoryEffect::hash(self : MemoryEffect) -> Int

    MemoryEffect::hash_combine

    source
    fn MemoryEffect::hash_combine(MemoryEffect, Hasher) -> Unit

    MemoryEffect::not_equal

    source
    fn MemoryEffect::not_equal(x : MemoryEffect, y : MemoryEffect) -> Bool

    MemoryEffect::to_repr

    source

    Operation

    source
    pub(all) enum Operation {
      I32Const(UInt)
      I64Const(UInt64)
      F32Const(UInt)
      F64Const(UInt64)
      V128Const(UInt64, UInt64)
      NullPtr
      NullGcRef
      CodeAddress(CodeSymbol)
      ExternalAddress(ExternalSymbol)
      DataAddress(DataSymbol)
      EnvironmentField(EnvironmentField, EnvironmentFieldStability)
      StackAddress(StackObject)
      Copy
      Select
      GcRefAddress
      GcRefFromBits
      PointerOffset
      ReferenceCompare(ReferenceComparison)
      IntUnary(IntUnaryOp)
      IntBinary(IntBinaryOp)
      IntHighMultiply(Signedness)
      IntWithOverflow(IntOverflowOp)
      IntCompare(IntComparison)
      FloatUnary(FloatUnaryOp)
      FloatBinary(FloatBinaryOp)
      FloatTernary(FloatTernaryOp)
      FloatCompare(FloatComparison)
      Convert(ConversionOp)
      Load(LoadSpec)
      Store(StoreSpec)
      AtomicLoad(AtomicSpec)
      AtomicStore(AtomicSpec)
      AtomicRmw(AtomicSpec, AtomicRmwOp)
      AtomicCompareExchange(AtomicSpec)
      AtomicFence
      Vector(VectorOp)
      VectorLoad(VectorLoadSpec)
      VectorStoreLane(VectorStoreLaneSpec)
      Call(SemanticCall)
      Safepoint(SafepointKind)
    } derive(Eq, 
    Debug    )

    Operation::equal

    source
    fn Operation::equal(Operation, Operation) -> Bool

    Operation::not_equal

    source
    fn Operation::not_equal(x : Operation, y : Operation) -> Bool

    Operation::semantics

    source
    fn Operation::semantics(self : Operation) -> OperationSemantics

    Operation::to_repr

    source

    OperationSemantics

    source
    pub struct OperationSemantics {
      memory : MemoryEffect
      may_trap : Bool
      may_unwind : Bool
      gc_safepoint : Bool
      cancellation_safepoint : Bool
      returns_twice : Bool
    } derive(Eq, Hash, 
    Debug    )

    Canonical observable behavior of one semantic operation.

    OperationSemantics::equal

    source

    OperationSemantics::hash

    source
    fn OperationSemantics::hash(self : OperationSemantics) -> Int

    OperationSemantics::hash_combine

    source
    fn OperationSemantics::hash_combine(OperationSemantics, Hasher) -> Unit

    OperationSemantics::must_preserve_if_unused

    source
    fn OperationSemantics::must_preserve_if_unused(self : OperationSemantics) -> Bool

    OperationSemantics::not_equal

    source

    OperationSemantics::pure

    source

    OperationSemantics::to_repr

    source

    ReferenceComparison

    source
    pub(all) enum ReferenceComparison {
      Equal
      NotEqual
    } derive(Eq, Hash, 
    Debug    )

    ReferenceComparison::equal

    source

    ReferenceComparison::hash

    source

    ReferenceComparison::hash_combine

    source

    ReferenceComparison::not_equal

    source

    ReferenceComparison::to_repr

    source

    SafepointKind

    source
    pub(all) enum SafepointKind {
      Gc
      Cancellation
      GcAndCancellation
    } derive(Eq, Hash, 
    Debug    )

    SafepointKind::equal

    source

    SafepointKind::hash

    source
    fn SafepointKind::hash(self : SafepointKind) -> Int

    SafepointKind::hash_combine

    source
    fn SafepointKind::hash_combine(SafepointKind, Hasher) -> Unit

    SafepointKind::not_equal

    source
    fn SafepointKind::not_equal(x : SafepointKind, y : SafepointKind) -> Bool

    SafepointKind::to_repr

    source

    SemanticCall

    source
    pub struct SemanticCall {
      callee : Callee
      signature : Signature
      protocol : CallProtocol
      behavior : CallBehavior
    } derive(Eq, Hash, 
    Debug    )

    SemanticCall::equal

    source

    SemanticCall::hash

    source
    fn SemanticCall::hash(self : SemanticCall) -> Int

    SemanticCall::hash_combine

    source
    fn SemanticCall::hash_combine(SemanticCall, Hasher) -> Unit

    SemanticCall::new

    source
    fn SemanticCall::new(callee : Callee, signature : Signature, protocol : CallProtocol, behavior : CallBehavior) -> SemanticCall

    SemanticCall::not_equal

    source
    fn SemanticCall::not_equal(x : SemanticCall, y : SemanticCall) -> Bool

    SemanticCall::to_repr

    source

    Signature

    source
    pub struct Signature {
      params : Array[ValueType]
      results : Array[ValueType]
    } derive(Eq, Hash, 
    Debug    )

    Ordered logical parameters and results. ABI placement is intentionally absent.

    Signature::equal

    source
    fn Signature::equal(Signature, Signature) -> Bool

    Signature::hash

    source
    fn Signature::hash(self : Signature) -> Int

    Signature::hash_combine

    source
    fn Signature::hash_combine(Signature, Hasher) -> Unit

    Signature::new

    source
    fn Signature::new(params : Array[ValueType], results : Array[ValueType]) -> Signature

    Signature::not_equal

    source
    fn Signature::not_equal(x : Signature, y : Signature) -> Bool

    Signature::to_repr

    source

    Signedness

    source
    pub(all) enum Signedness {
      Signed
      Unsigned
    } derive(Eq, Hash, 
    Debug    )

    Signedness::equal

    source
    fn Signedness::equal(Signedness, Signedness) -> Bool

    Signedness::hash

    source
    fn Signedness::hash(self : Signedness) -> Int

    Signedness::hash_combine

    source
    fn Signedness::hash_combine(Signedness, Hasher) -> Unit

    Signedness::not_equal

    source
    fn Signedness::not_equal(x : Signedness, y : Signedness) -> Bool

    Signedness::to_repr

    source

    SourceLocation

    source
    pub struct SourceLocation {
      file : String
      line : Int
      column : Int
    } derive(Eq, Hash, 
    Debug    )

    SourceLocation::equal

    source

    SourceLocation::hash

    source
    fn SourceLocation::hash(self : SourceLocation) -> Int

    SourceLocation::hash_combine

    source
    fn SourceLocation::hash_combine(SourceLocation, Hasher) -> Unit

    SourceLocation::new

    source
    fn SourceLocation::new(file : String, line : Int, column : Int) -> SourceLocation

    SourceLocation::not_equal

    source
    fn SourceLocation::not_equal(x : SourceLocation, y : SourceLocation) -> Bool

    SourceLocation::to_repr

    source

    StackMapArgumentRoots

    source
    pub(all) enum StackMapArgumentRoots {
      Fixed(Int)
      I32ConstantOperand(Int)
      AllocationOperands
    } derive(Eq, 
    Debug    )

    How a hidden safepoint describes roots already present in its arguments.

    StackMapArgumentRoots::equal

    source

    StackMapArgumentRoots::not_equal

    source

    StackMapArgumentRoots::to_repr

    source

    StackMapMetadata

    source
    pub struct StackMapMetadata {
      id : Int
      argument_root_count : Int
    } derive(Eq, 
    Debug    )

    StackMapMetadata::equal

    source

    StackMapMetadata::new

    source
    fn StackMapMetadata::new(id : Int, argument_root_count~ : Int) -> StackMapMetadata

    StackMapMetadata::not_equal

    source
    fn StackMapMetadata::not_equal(x : StackMapMetadata, y : StackMapMetadata) -> Bool

    StackMapMetadata::to_repr

    source

    StackObject

    source
    pub struct StackObject {
      // private fields
    }

    Opaque function-owned address-visible stack object handle.
    impl Eq for StackObject
    impl Hash for StackObject

    StackObject::equal

    source
    fn StackObject::equal(self : StackObject, other : StackObject) -> Bool

    StackObject::hash

    source
    fn StackObject::hash(self : StackObject) -> Int

    StackObject::hash_combine

    source
    fn StackObject::hash_combine(self : StackObject, hasher : Hasher) -> Unit

    StackObject::not_equal

    source
    fn StackObject::not_equal(x : StackObject, y : StackObject) -> Bool

    StackObject::to_repr

    source

    StoreSpec

    source
    pub struct StoreSpec {
      width : AccessWidth
      value_type : ValueType
      offset : UInt64
      endianness : Endianness
      trap : TrapReason?
    } derive(Eq, Hash, 
    Debug    )

    StoreSpec::equal

    source
    fn StoreSpec::equal(StoreSpec, StoreSpec) -> Bool

    StoreSpec::hash

    source
    fn StoreSpec::hash(self : StoreSpec) -> Int

    StoreSpec::hash_combine

    source
    fn StoreSpec::hash_combine(StoreSpec, Hasher) -> Unit

    StoreSpec::new

    source
    fn StoreSpec::new(width : AccessWidth, value_type : ValueType, offset : UInt64, endianness : Endianness, trap : TrapReason?) -> StoreSpec

    StoreSpec::not_equal

    source
    fn StoreSpec::not_equal(x : StoreSpec, y : StoreSpec) -> Bool

    StoreSpec::to_repr

    source

    SwitchCase

    source
    pub struct SwitchCase {
      bits : UInt64
      edge : Edge
    } derive(Eq, 
    Debug    )

    SwitchCase::equal

    source
    fn SwitchCase::equal(SwitchCase, SwitchCase) -> Bool

    SwitchCase::not_equal

    source
    fn SwitchCase::not_equal(x : SwitchCase, y : SwitchCase) -> Bool

    SwitchCase::to_repr

    source

    Terminator

    source
    pub(all) enum Terminator {
      Jump(Edge)
      Branch(Value, Edge, Edge)
      Switch(Value, Array[SwitchCase], Edge)
      Return(Array[Value])
      TailCall(SemanticCall, Array[Value])
      NoReturnCall(SemanticCall, Array[Value])
      Trap(TrapReason)
    } derive(Eq, 
    Debug    )

    Terminator::equal

    source
    fn Terminator::equal(Terminator, Terminator) -> Bool

    Terminator::not_equal

    source
    fn Terminator::not_equal(x : Terminator, y : Terminator) -> Bool

    Terminator::to_repr

    source

    TerminatorMetadata

    source
    pub struct TerminatorMetadata {
      source : SourceLocation?
      live_gc_roots : Array[Value]
    } derive(Eq, 
    Debug    )

    TerminatorMetadata::empty

    source

    TerminatorMetadata::equal

    source

    TerminatorMetadata::new

    source
    fn TerminatorMetadata::new(source : SourceLocation?, live_gc_roots : Array[Value]) -> TerminatorMetadata

    TerminatorMetadata::not_equal

    source

    TerminatorMetadata::to_repr

    source

    TerminatorRecord

    source
    pub struct TerminatorRecord {
      kind : Terminator
      metadata : TerminatorMetadata
    } derive(Eq, 
    Debug    )

    TerminatorRecord::equal

    source

    TerminatorRecord::not_equal

    source
    fn TerminatorRecord::not_equal(x : TerminatorRecord, y : TerminatorRecord) -> Bool

    TerminatorRecord::to_repr

    source

    TrapReason

    source
    pub(all) enum TrapReason {
      Unreachable
      IntegerDivisionByZero
      IntegerOverflow
      InvalidConversionToInteger
      MemoryOutOfBounds
      TableOutOfBounds
      IndirectCallTypeMismatch
      NullReference
      UnalignedAtomic
      UnsupportedOperation
      StackOverflow
      User(Int)
    } derive(Eq, Hash, 
    Debug    )

    TrapReason::equal

    source
    fn TrapReason::equal(TrapReason, TrapReason) -> Bool

    TrapReason::hash

    source
    fn TrapReason::hash(self : TrapReason) -> Int

    TrapReason::hash_combine

    source
    fn TrapReason::hash_combine(TrapReason, Hasher) -> Unit

    TrapReason::not_equal

    source
    fn TrapReason::not_equal(x : TrapReason, y : TrapReason) -> Bool

    TrapReason::to_repr

    source

    Value

    source
    pub struct Value {
      // private fields
    }

    Opaque function-owned SSA value handle.
    impl Eq for Value
    impl Hash for Value
    impl Debug for Value

    Value::equal

    source
    fn Value::equal(self : Value, other : Value) -> Bool

    Value::hash

    source
    fn Value::hash(self : Value) -> Int

    Value::hash_combine

    source
    fn Value::hash_combine(self : Value, hasher : Hasher) -> Unit

    Value::not_equal

    source
    fn Value::not_equal(x : Value, y : Value) -> Bool

    Value::to_repr

    source

    ValueType

    source
    pub(all) enum ValueType {
      I32
      I64
      F32
      F64
      V128
      Ptr64
      GcRef64
    } derive(Eq, Hash, 
    Debug    )

    Exact target-neutral value types carried by semantic MachV SSA values.

    Ptr64 is an untraced address or opaque handle. GcRef64 is a nullable managed reference and must be reported as a root at GC safepoints.
    impl Show for ValueType

    ValueType::equal

    source
    fn ValueType::equal(ValueType, ValueType) -> Bool

    ValueType::hash

    source
    fn ValueType::hash(self : ValueType) -> Int

    ValueType::hash_combine

    source
    fn ValueType::hash_combine(ValueType, Hasher) -> Unit

    ValueType::not_equal

    source
    fn ValueType::not_equal(x : ValueType, y : ValueType) -> Bool

    ValueType::output

    source
    fn ValueType::output(self : ValueType, logger : &Logger) -> Unit

    ValueType::to_repr

    source

    ValueType::to_string

    source
    fn ValueType::to_string(self : ValueType) -> String

    VectorBitwiseOp

    source
    pub(all) enum VectorBitwiseOp {
      Not
      And
      Or
      Xor
      AndNot
      BitSelect
    } derive(Eq, Hash, 
    Debug    )

    VectorBitwiseOp::equal

    source

    VectorBitwiseOp::hash

    source
    fn VectorBitwiseOp::hash(self : VectorBitwiseOp) -> Int

    VectorBitwiseOp::hash_combine

    source
    fn VectorBitwiseOp::hash_combine(VectorBitwiseOp, Hasher) -> Unit

    VectorBitwiseOp::not_equal

    source
    fn VectorBitwiseOp::not_equal(x : VectorBitwiseOp, y : VectorBitwiseOp) -> Bool

    VectorBitwiseOp::to_repr

    source

    VectorConversionOp

    source
    pub(all) enum VectorConversionOp {
      ExtendLow(VectorLane, Signedness)
      ExtendHigh(VectorLane, Signedness)
      Narrow(VectorLane, Signedness)
      FloatToInt(VectorLane, VectorLane, Signedness, ConversionMode)
      IntToFloat(VectorLane, VectorLane, Signedness)
      PromoteLowF32x4
      DemoteZeroF64x2
    } derive(Eq, Hash, 
    Debug    )

    VectorConversionOp::equal

    source

    VectorConversionOp::hash

    source
    fn VectorConversionOp::hash(self : VectorConversionOp) -> Int

    VectorConversionOp::hash_combine

    source
    fn VectorConversionOp::hash_combine(VectorConversionOp, Hasher) -> Unit

    VectorConversionOp::not_equal

    source

    VectorConversionOp::to_repr

    source

    VectorFloatBinaryOp

    source
    pub(all) enum VectorFloatBinaryOp {
      Add
      Sub
      Mul
      Div
      Min
      Max
      PseudoMin
      PseudoMax
    } derive(Eq, Hash, 
    Debug    )

    VectorFloatBinaryOp::equal

    source

    VectorFloatBinaryOp::hash

    source

    VectorFloatBinaryOp::hash_combine

    source

    VectorFloatBinaryOp::not_equal

    source

    VectorFloatBinaryOp::to_repr

    source

    VectorFloatComparison

    source
    pub(all) enum VectorFloatComparison {
      Equal
      NotEqual
      LessThan
      LessOrEqual
      GreaterThan
      GreaterOrEqual
    } derive(Eq, Hash, 
    Debug    )

    VectorFloatComparison::equal

    source

    VectorFloatComparison::hash

    source

    VectorFloatComparison::hash_combine

    source

    VectorFloatComparison::not_equal

    source

    VectorFloatComparison::to_repr

    source

    VectorFloatUnaryOp

    source
    pub(all) enum VectorFloatUnaryOp {
      Absolute
      Negate
      SquareRoot
      Ceil
      Floor
      Truncate
      Nearest
    } derive(Eq, Hash, 
    Debug    )

    VectorFloatUnaryOp::equal

    source

    VectorFloatUnaryOp::hash

    source
    fn VectorFloatUnaryOp::hash(self : VectorFloatUnaryOp) -> Int

    VectorFloatUnaryOp::hash_combine

    source
    fn VectorFloatUnaryOp::hash_combine(VectorFloatUnaryOp, Hasher) -> Unit

    VectorFloatUnaryOp::not_equal

    source

    VectorFloatUnaryOp::to_repr

    source

    VectorHalf

    source
    pub(all) enum VectorHalf {
      Low
      High
    } derive(Eq, Hash, 
    Debug    )

    VectorHalf::equal

    source
    fn VectorHalf::equal(VectorHalf, VectorHalf) -> Bool

    VectorHalf::hash

    source
    fn VectorHalf::hash(self : VectorHalf) -> Int

    VectorHalf::hash_combine

    source
    fn VectorHalf::hash_combine(VectorHalf, Hasher) -> Unit

    VectorHalf::not_equal

    source
    fn VectorHalf::not_equal(x : VectorHalf, y : VectorHalf) -> Bool

    VectorHalf::to_repr

    source

    VectorIntBinaryOp

    source
    pub(all) enum VectorIntBinaryOp {
      Add
      Sub
      Mul
      Min(Signedness)
      Max(Signedness)
      AverageUnsigned
      SaturatingAdd(Signedness)
      SaturatingSub(Signedness)
      ExtendMultiply(VectorHalf, Signedness)
      Dot16To32Signed
      Q15MultiplyRoundedSaturating
    } derive(Eq, Hash, 
    Debug    )

    VectorIntBinaryOp::equal

    source

    VectorIntBinaryOp::hash

    source
    fn VectorIntBinaryOp::hash(self : VectorIntBinaryOp) -> Int

    VectorIntBinaryOp::hash_combine

    source
    fn VectorIntBinaryOp::hash_combine(VectorIntBinaryOp, Hasher) -> Unit

    VectorIntBinaryOp::not_equal

    source
    fn VectorIntBinaryOp::not_equal(x : VectorIntBinaryOp, y : VectorIntBinaryOp) -> Bool

    VectorIntBinaryOp::to_repr

    source

    VectorIntComparison

    source
    pub(all) enum VectorIntComparison {
      Equal
      NotEqual
      LessThan(Signedness)
      LessOrEqual(Signedness)
      GreaterThan(Signedness)
      GreaterOrEqual(Signedness)
    } derive(Eq, Hash, 
    Debug    )

    VectorIntComparison::equal

    source

    VectorIntComparison::hash

    source

    VectorIntComparison::hash_combine

    source

    VectorIntComparison::not_equal

    source

    VectorIntComparison::to_repr

    source

    VectorIntShiftOp

    source
    pub(all) enum VectorIntShiftOp {
      Left
      Right(Signedness)
    } derive(Eq, Hash, 
    Debug    )

    VectorIntShiftOp::equal

    source

    VectorIntShiftOp::hash

    source
    fn VectorIntShiftOp::hash(self : VectorIntShiftOp) -> Int

    VectorIntShiftOp::hash_combine

    source
    fn VectorIntShiftOp::hash_combine(VectorIntShiftOp, Hasher) -> Unit

    VectorIntShiftOp::not_equal

    source
    fn VectorIntShiftOp::not_equal(x : VectorIntShiftOp, y : VectorIntShiftOp) -> Bool

    VectorIntShiftOp::to_repr

    source

    VectorIntUnaryOp

    source
    pub(all) enum VectorIntUnaryOp {
      Absolute
      Negate
      PopulationCount
      ExtendAddPairwise(Signedness)
    } derive(Eq, Hash, 
    Debug    )

    VectorIntUnaryOp::equal

    source

    VectorIntUnaryOp::hash

    source
    fn VectorIntUnaryOp::hash(self : VectorIntUnaryOp) -> Int

    VectorIntUnaryOp::hash_combine

    source
    fn VectorIntUnaryOp::hash_combine(VectorIntUnaryOp, Hasher) -> Unit

    VectorIntUnaryOp::not_equal

    source
    fn VectorIntUnaryOp::not_equal(x : VectorIntUnaryOp, y : VectorIntUnaryOp) -> Bool

    VectorIntUnaryOp::to_repr

    source

    VectorLane

    source
    pub(all) enum VectorLane {
      I8x16
      I16x8
      I32x4
      I64x2
      F32x4
      F64x2
    } derive(Eq, Hash, 
    Debug    )

    VectorLane::equal

    source
    fn VectorLane::equal(VectorLane, VectorLane) -> Bool

    VectorLane::hash

    source
    fn VectorLane::hash(self : VectorLane) -> Int

    VectorLane::hash_combine

    source
    fn VectorLane::hash_combine(VectorLane, Hasher) -> Unit

    VectorLane::not_equal

    source
    fn VectorLane::not_equal(x : VectorLane, y : VectorLane) -> Bool

    VectorLane::to_repr

    source

    VectorLoadKind

    source
    pub(all) enum VectorLoadKind {
      Splat(VectorLane)
      Extend(VectorLane, Signedness)
      Zero(AccessWidth)
      Lane(VectorLane, Int)
    } derive(Eq, Hash, 
    Debug    )

    VectorLoadKind::equal

    source

    VectorLoadKind::hash

    source
    fn VectorLoadKind::hash(self : VectorLoadKind) -> Int

    VectorLoadKind::hash_combine

    source
    fn VectorLoadKind::hash_combine(VectorLoadKind, Hasher) -> Unit

    VectorLoadKind::not_equal

    source
    fn VectorLoadKind::not_equal(x : VectorLoadKind, y : VectorLoadKind) -> Bool

    VectorLoadKind::to_repr

    source

    VectorLoadSpec

    source
    pub struct VectorLoadSpec {
      kind : VectorLoadKind
      offset : UInt64
      endianness : Endianness
      trap : TrapReason?
    } derive(Eq, Hash, 
    Debug    )

    VectorLoadSpec::equal

    source

    VectorLoadSpec::hash

    source
    fn VectorLoadSpec::hash(self : VectorLoadSpec) -> Int

    VectorLoadSpec::hash_combine

    source
    fn VectorLoadSpec::hash_combine(VectorLoadSpec, Hasher) -> Unit

    VectorLoadSpec::new

    source
    fn VectorLoadSpec::new(kind : VectorLoadKind, offset : UInt64, endianness : Endianness, trap : TrapReason?) -> VectorLoadSpec

    VectorLoadSpec::not_equal

    source
    fn VectorLoadSpec::not_equal(x : VectorLoadSpec, y : VectorLoadSpec) -> Bool

    VectorLoadSpec::to_repr

    source

    VectorOp

    source
    pub(all) enum VectorOp {
      Splat(VectorLane)
      ExtractLane(VectorLane, Int, Signedness?)
      ReplaceLane(VectorLane, Int)
      Shuffle(FixedArray[Int])
      Swizzle
      Bitwise(VectorBitwiseOp)
      IntUnary(VectorLane, VectorIntUnaryOp)
      IntBinary(VectorLane, VectorIntBinaryOp)
      IntShift(VectorLane, VectorIntShiftOp)
      IntCompare(VectorLane, VectorIntComparison)
      FloatUnary(VectorLane, VectorFloatUnaryOp)
      FloatBinary(VectorLane, VectorFloatBinaryOp)
      FloatTernary(VectorLane, FloatTernaryOp)
      FloatCompare(VectorLane, VectorFloatComparison)
      Predicate(VectorPredicateOp)
      Convert(VectorConversionOp)
      Relaxed(VectorRelaxedOp)
    } derive(Eq, 
    Debug    )

    VectorOp::equal

    source
    fn VectorOp::equal(VectorOp, VectorOp) -> Bool

    VectorOp::not_equal

    source
    fn VectorOp::not_equal(x : VectorOp, y : VectorOp) -> Bool

    VectorOp::to_repr

    source

    VectorPredicateOp

    source
    pub(all) enum VectorPredicateOp {
      AnyTrue
      AllTrue(VectorLane)
      BitMask(VectorLane)
    } derive(Eq, Hash, 
    Debug    )

    VectorPredicateOp::equal

    source

    VectorPredicateOp::hash

    source
    fn VectorPredicateOp::hash(self : VectorPredicateOp) -> Int

    VectorPredicateOp::hash_combine

    source
    fn VectorPredicateOp::hash_combine(VectorPredicateOp, Hasher) -> Unit

    VectorPredicateOp::not_equal

    source
    fn VectorPredicateOp::not_equal(x : VectorPredicateOp, y : VectorPredicateOp) -> Bool

    VectorPredicateOp::to_repr

    source

    VectorRelaxedOp

    source
    pub(all) enum VectorRelaxedOp {
      Swizzle
      FloatToInt(VectorLane, VectorLane, Signedness)
      FusedMultiplyAdd(VectorLane, FloatTernaryOp)
      LaneSelect(VectorLane)
      Min(VectorLane)
      Max(VectorLane)
      Q15MultiplyRoundedSigned
      Dot8To16Signed
      Dot8To32AddSigned
    } derive(Eq, Hash, 
    Debug    )

    VectorRelaxedOp::equal

    source

    VectorRelaxedOp::hash

    source
    fn VectorRelaxedOp::hash(self : VectorRelaxedOp) -> Int

    VectorRelaxedOp::hash_combine

    source
    fn VectorRelaxedOp::hash_combine(VectorRelaxedOp, Hasher) -> Unit

    VectorRelaxedOp::not_equal

    source
    fn VectorRelaxedOp::not_equal(x : VectorRelaxedOp, y : VectorRelaxedOp) -> Bool

    VectorRelaxedOp::to_repr

    source

    VectorStoreLaneSpec

    source
    pub struct VectorStoreLaneSpec {
      lane : VectorLane
      lane_index : Int
      offset : UInt64
      endianness : Endianness
      trap : TrapReason?
    } derive(Eq, Hash, 
    Debug    )

    VectorStoreLaneSpec::equal

    source

    VectorStoreLaneSpec::hash

    source

    VectorStoreLaneSpec::hash_combine

    source

    VectorStoreLaneSpec::new

    source
    fn VectorStoreLaneSpec::new(lane : VectorLane, lane_index : Int, offset : UInt64, endianness : Endianness, trap : TrapReason?) -> VectorStoreLaneSpec

    VectorStoreLaneSpec::not_equal

    source

    VectorStoreLaneSpec::to_repr

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io