🥮 mooncakes.io

    Milky2018/vcode/native_types does not have a README file

    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

    CallBehavior

    source
    pub(all) 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    )

    Native call target selected during streaming lowering.

    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

    CodeSymbol

    source
    pub(all) 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

    DataSymbol

    source
    pub(all) 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

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

    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

    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

    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

    NativeCall

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

    Target-independent native call contract. This is ABI metadata, not an instruction or an intermediate representation node.

    NativeCall::copy

    source
    fn NativeCall::copy(self : NativeCall) -> NativeCall

    NativeCall::equal

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

    NativeCall::hash

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

    NativeCall::hash_combine

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

    NativeCall::new

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

    NativeCall::not_equal

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

    NativeCall::to_repr

    source

    OperationSemantics

    source
    pub(all) 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

    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

    Signature

    source
    pub(all) 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(all) 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::is_valid

    source
    fn SourceLocation::is_valid(self : SourceLocation) -> Bool

    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

    StackMapMetadata

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

    Embedding-visible stack-map identity and argument-root contract.

    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(all) struct StackObject {
      id : Int
    } derive(Eq, Hash, 
    Debug    )

    Function-local stack-object request used during native lowering. The id is interpreted only by the current target-lowering session.

    StackObject::equal

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

    StackObject::hash

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

    StackObject::hash_combine

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

    StackObject::not_equal

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

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

    ValueType

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

    Exact target-neutral value types shared by native lowering and target VCode.

    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

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io