🥮 mooncakes.io
    Sign in

    machv

    Target-neutral semantic machine IR

    compiler
    machine-ir
    codegen
    jit
    Download zip
    Author
    Version
    0.7.1
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    296

    #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. A target may rematerialize either form, but it may reuse only stable fields according to its own instruction and register-pressure cost model. Field offsets and runtime layout remain embedding-provided ABI data.

    Function::environment_field_use_groups derives target-neutral field/context occurrence groups, call-free regions, context use counts, and the conservative fact that a stable result can replace an exclusive context carrier. It does not choose whether a target should keep the value live; that profitability policy belongs to target lowering.

    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.

    AccessWidth

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

    AtomicRmwOp

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

    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::new

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

    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

    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::new

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

    CallBehavior::semantics

    source

    CallProtocol

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

    Callee

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

    CleanupStats

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

    CodeSymbol

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

    CodeSymbol::new

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

    ConversionMode

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

    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    )

    DataSymbol

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

    DataSymbol::new

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

    Edge

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

    Endianness

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

    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::new

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

    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.

    EnvironmentFieldUseGroup

    source
    pub struct EnvironmentFieldUseGroup {
      field : EnvironmentField
      stability : EnvironmentFieldStability
      context : Value
      occurrences : Array[Instruction]
      call_free_regions : Array[EnvironmentFieldUseRegion]
      context_use_count : Int
      can_replace_context_carrier : Bool
    } derive(Eq, 
    Debug    )

    EnvironmentFieldUseRegion

    source
    pub struct EnvironmentFieldUseRegion {
      block : Block
      segment_index : Int
      occurrences : Array[Instruction]
    } derive(Eq, 
    Debug    )

    ExternalSymbol

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

    ExternalSymbol::new

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

    FloatBinaryOp

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

    FloatComparison

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

    FloatTernaryOp

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

    FloatType

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

    FloatUnaryOp

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

    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::environment_field_use_groups

    source
    fn Function::environment_field_use_groups(self : Function) -> Array[EnvironmentFieldUseGroup]

    Analyze environment-field identity and use regions without selecting a target materialization policy.

    The input must already be verified. A call starts a new physical-pressure segment, but does not change the semantic stability of a field.

    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::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::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::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

    Instruction

    source
    pub struct Instruction {
      // private fields
    }

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

    InstructionMetadata

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

    InstructionMetadata::empty

    source

    InstructionMetadata::new

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

    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    )

    IntComparison

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

    IntOverflowOp

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

    IntUnaryOp

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

    IntegerType

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

    LoadExtension

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

    LoadSpec

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

    LoadSpec::new

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

    MemoryEffect

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

    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::semantics

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

    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::must_preserve_if_unused

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

    OperationSemantics::pure

    source

    ReferenceComparison

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

    SafepointKind

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

    SemanticCall

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

    SemanticCall::new

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

    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::new

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

    Signedness

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

    SourceLocation

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

    SourceLocation::new

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

    StackMapMetadata

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

    StackMapMetadata::new

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

    StackObject

    source
    pub struct StackObject {
      // private fields
    }

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

    StoreSpec

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

    StoreSpec::new

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

    SwitchCase

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

    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    )

    TerminatorMetadata

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

    TerminatorMetadata::empty

    source

    TerminatorMetadata::new

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

    TerminatorRecord

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

    TrapReason

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

    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

    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

    VectorBitwiseOp

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

    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    )

    VectorFloatBinaryOp

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

    VectorFloatComparison

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

    VectorFloatUnaryOp

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

    VectorHalf

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

    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    )

    VectorIntComparison

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

    VectorIntShiftOp

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

    VectorIntUnaryOp

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

    VectorLane

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

    VectorLoadKind

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

    VectorLoadSpec

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

    VectorLoadSpec::new

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

    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    )

    VectorPredicateOp

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

    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    )

    VectorStoreLaneSpec

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

    VectorStoreLaneSpec::new

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

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io