🥮 mooncakes.io
    Sign in

    jtenner/starshine/representation does not have a README file

    AccessFacts

    source
    pub struct AccessFacts {
      in_bounds : Bool
      alignment_log2 : UInt?
    } derive(Eq, Hash, 
    Debug    )

    AccessFacts::new

    source
    fn AccessFacts::new(in_bounds? : Bool, alignment_log2? : UInt?) -> AccessFacts

    AccessSiteFacts

    source
    pub struct AccessSiteFacts {
      site : CodeSite
      facts : AccessFacts
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    AccessSiteFacts::new

    source
    fn AccessSiteFacts::new(site : CodeSite, facts : AccessFacts, provenance? : SourceProvenance?) -> AccessSiteFacts

    AliasSource

    source
    pub enum AliasSource {
      ParameterAlias(UInt)
      GlobalAlias(UInt)
      SiteAlias(ValueSite)
    } derive(Eq, Hash, 
    Debug    )

    AliasSource::global

    source
    fn AliasSource::global(global : UInt) -> AliasSource

    AliasSource::parameter

    source
    fn AliasSource::parameter(parameter : UInt) -> AliasSource

    AliasSource::site

    source
    fn AliasSource::site(site : ValueSite) -> AliasSource

    AllocationFacts

    source
    pub struct AllocationFacts {
      kind : AllocationKind
      escape_sinks : EscapeSinkMask?
      identity_unobserved : Bool
      thread_confined : Bool
      length : IntegerFacts?
      fields : Array[AllocationFieldFacts]
    } derive(Eq, Hash, 
    Debug    )

    AllocationFacts::new

    source
    fn AllocationFacts::new(kind : AllocationKind, escape_sinks? : EscapeSinkMask?, identity_unobserved? : Bool, thread_confined? : Bool, length? : IntegerFacts?, fields? : Array[AllocationFieldFacts]) -> AllocationFacts

    AllocationFieldFacts

    source
    pub struct AllocationFieldFacts {
      field : UInt
      no_post_init_writes : Bool
      stored_value : ValueFacts?
    } derive(Eq, Hash, 
    Debug    )

    AllocationFieldFacts::new

    source
    fn AllocationFieldFacts::new(field : UInt, no_post_init_writes? : Bool, stored_value? : ValueFacts?) -> AllocationFieldFacts

    AllocationKind

    source
    pub enum AllocationKind {
      StructAllocation(UInt)
      ArrayAllocation(UInt)
      ClosureAllocation(UInt)
      BoxAllocation(UInt)
      OtherGcAllocation(UInt)
    } derive(Eq, Hash, 
    Debug    )

    AllocationKind::array

    source
    fn AllocationKind::array(type_ : UInt) -> AllocationKind

    AllocationKind::box

    source
    fn AllocationKind::box(type_ : UInt) -> AllocationKind

    AllocationKind::closure

    source
    fn AllocationKind::closure(type_ : UInt) -> AllocationKind

    AllocationKind::other_gc

    source
    fn AllocationKind::other_gc(type_ : UInt) -> AllocationKind

    AllocationKind::struct_

    source
    fn AllocationKind::struct_(type_ : UInt) -> AllocationKind

    AllocationSiteFacts

    source
    pub struct AllocationSiteFacts {
      site : ValueSite
      facts : AllocationFacts
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    AllocationSiteFacts::new

    source

    ArrayElementFacts

    source
    pub struct ArrayElementFacts {
      view : TypeView
      stored_contents : ValueFacts?
      writes : WriteFacts?
    } derive(Eq, Hash, 
    Debug    )

    ArrayElementFacts::new

    source
    fn ArrayElementFacts::new(view : TypeView, stored_contents? : ValueFacts?, writes? : WriteFacts?) -> ArrayElementFacts

    BranchFacts

    source
    pub struct BranchFacts {
      site : CodeSite
      profile : BranchProfile?
      temperature : TemperatureHint?
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    BranchFacts::new

    source
    fn BranchFacts::new(site : CodeSite, profile? : BranchProfile?, temperature? : TemperatureHint?, provenance? : SourceProvenance?) -> BranchFacts

    BranchProfile

    source
    pub struct BranchProfile {
      taken : UInt64
      not_taken : UInt64
    } derive(Eq, Hash, 
    Debug    )

    BranchProfile::new

    source
    fn BranchProfile::new(taken : UInt64, not_taken : UInt64) -> BranchProfile

    CallProfile

    source
    pub struct CallProfile {
      count : UInt64?
      temperature : TemperatureHint?
    } derive(Eq, Hash, 
    Debug    )

    CallProfile::new

    source
    fn CallProfile::new(count? : UInt64?, temperature? : TemperatureHint?) -> CallProfile

    CallSiteFacts

    source
    pub struct CallSiteFacts {
      site : CodeSite
      direct_target : UInt?
      profile : CallProfile?
      inline_policy : InlinePolicy?
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    CallSiteFacts::new

    source
    fn CallSiteFacts::new(site : CodeSite, direct_target? : UInt?, profile? : CallProfile?, inline_policy? : InlinePolicy?, provenance? : SourceProvenance?) -> CallSiteFacts

    ClosedAliasSet

    source
    pub struct ClosedAliasSet(Array[AliasSource]) derive(Eq, Hash, 
    Debug    )

    ClosedAliasSet::new

    source

    ClosedFunctionSet

    source
    pub struct ClosedFunctionSet(Array[UInt]) derive(Eq, Hash, 
    Debug    )

    ClosedFunctionSet::new

    source
    fn ClosedFunctionSet::new(values : Array[UInt]) -> ClosedFunctionSet

    ClosedGlobalSet

    source
    pub struct ClosedGlobalSet(Array[UInt]) derive(Eq, Hash, 
    Debug    )

    ClosedGlobalSet::new

    source
    fn ClosedGlobalSet::new(values : Array[UInt]) -> ClosedGlobalSet

    ClosedHeapTypeSet

    source
    pub struct ClosedHeapTypeSet(Array[FactHeapType]) derive(Eq, Hash, 
    Debug    )

    ClosedHeapTypeSet::new

    source

    ClosedMemorySet

    source
    pub struct ClosedMemorySet(Array[UInt]) derive(Eq, Hash, 
    Debug    )

    ClosedMemorySet::new

    source
    fn ClosedMemorySet::new(values : Array[UInt]) -> ClosedMemorySet

    ClosedTableSet

    source
    pub struct ClosedTableSet(Array[UInt]) derive(Eq, Hash, 
    Debug    )

    ClosedTableSet::new

    source
    fn ClosedTableSet::new(values : Array[UInt]) -> ClosedTableSet

    ClosedTypeViewSet

    source
    pub struct ClosedTypeViewSet(Array[UInt]) derive(Eq, Hash, 
    Debug    )

    ClosedTypeViewSet::new

    source
    fn ClosedTypeViewSet::new(values : Array[UInt]) -> ClosedTypeViewSet

    ClosedValueSet

    source
    pub struct ClosedValueSet(Array[FactValue]) derive(Eq, Hash, 
    Debug    )

    Some(empty) means impossible; None means unknown.

    ClosedValueSet::new

    source

    CodeSite

    source
    pub struct CodeSite {
      function : UInt
      offset : UInt
    } derive(Eq, Hash, 
    Debug    )

    CodeSite::new

    source
    fn CodeSite::new(function : UInt, offset : UInt) -> CodeSite

    CompilerFactCustomSection

    source
    pub struct CompilerFactCustomSection {
      version : UInt
      module_fingerprint : Bytes?
      facts : OptimizationFactsSec
    } derive(Eq, Hash, 
    Debug    )

    chooses to trust semantic assertions after structural validation.

    CompilerFactCustomSection::new

    source
    fn CompilerFactCustomSection::new(facts : OptimizationFactsSec, version? : UInt, module_fingerprint? : Bytes?) -> CompilerFactCustomSection

    EffectFacts

    source
    pub struct EffectFacts {
      may : EffectMask
      read_globals : ClosedGlobalSet?
      written_globals : ClosedGlobalSet?
      read_memories : ClosedMemorySet?
      written_memories : ClosedMemorySet?
      read_tables : ClosedTableSet?
      written_tables : ClosedTableSet?
      read_heap_types : ClosedTypeViewSet?
      written_heap_types : ClosedTypeViewSet?
      direct_callees : ClosedFunctionSet?
    } derive(Eq, Hash, 
    Debug    )

    EffectFacts::new

    source
    fn EffectFacts::new(may : EffectMask, read_globals? : ClosedGlobalSet?, written_globals? : ClosedGlobalSet?, read_memories? : ClosedMemorySet?, written_memories? : ClosedMemorySet?, read_tables? : ClosedTableSet?, written_tables? : ClosedTableSet?, read_heap_types? : ClosedTypeViewSet?, written_heap_types? : ClosedTypeViewSet?, direct_callees? : ClosedFunctionSet?) -> EffectFacts

    EffectMask

    source
    pub struct EffectMask(UInt64) derive(Eq, Hash, 
    Debug    )

    when present; an absent set means unknown, never empty.

    EffectMask::allocation

    source
    fn EffectMask::allocation() -> EffectMask

    EffectMask::bits

    source
    fn EffectMask::bits(self : EffectMask) -> UInt64

    EffectMask::call

    source
    fn EffectMask::call() -> EffectMask

    EffectMask::contains

    source
    fn EffectMask::contains(self : EffectMask, other : EffectMask) -> Bool

    EffectMask::control

    source
    fn EffectMask::control() -> EffectMask

    EffectMask::empty

    source
    fn EffectMask::empty() -> EffectMask

    EffectMask::from_bits

    source
    fn EffectMask::from_bits(bits : UInt64) -> EffectMask

    EffectMask::global_state

    source
    fn EffectMask::global_state() -> EffectMask

    EffectMask::heap_read

    source
    fn EffectMask::heap_read() -> EffectMask

    EffectMask::heap_write

    source
    fn EffectMask::heap_write() -> EffectMask

    EffectMask::local_state

    source
    fn EffectMask::local_state() -> EffectMask

    EffectMask::may_allocate_gc

    source
    fn EffectMask::may_allocate_gc() -> EffectMask

    EffectMask::may_call_host_code

    source
    fn EffectMask::may_call_host_code() -> EffectMask

    EffectMask::may_call_unknown_code

    source
    fn EffectMask::may_call_unknown_code() -> EffectMask

    EffectMask::may_diverge

    source
    fn EffectMask::may_diverge() -> EffectMask

    EffectMask::may_grow_memory

    source
    fn EffectMask::may_grow_memory() -> EffectMask

    EffectMask::may_grow_table

    source
    fn EffectMask::may_grow_table() -> EffectMask

    EffectMask::may_observe_reference_identity

    source
    fn EffectMask::may_observe_reference_identity() -> EffectMask

    EffectMask::may_produce_nondeterministic_results

    source
    fn EffectMask::may_produce_nondeterministic_results() -> EffectMask

    EffectMask::may_read_gc_heap

    source
    fn EffectMask::may_read_gc_heap() -> EffectMask

    EffectMask::may_read_global

    source
    fn EffectMask::may_read_global() -> EffectMask

    EffectMask::may_read_memory

    source
    fn EffectMask::may_read_memory() -> EffectMask

    EffectMask::may_read_table

    source
    fn EffectMask::may_read_table() -> EffectMask

    EffectMask::may_reenter

    source
    fn EffectMask::may_reenter() -> EffectMask

    EffectMask::may_suspend

    source
    fn EffectMask::may_suspend() -> EffectMask

    EffectMask::may_synchronize

    source
    fn EffectMask::may_synchronize() -> EffectMask

    EffectMask::may_throw

    source
    fn EffectMask::may_throw() -> EffectMask

    EffectMask::may_trap

    source
    fn EffectMask::may_trap() -> EffectMask

    EffectMask::may_wait_or_notify

    source
    fn EffectMask::may_wait_or_notify() -> EffectMask

    EffectMask::may_write_gc_heap

    source
    fn EffectMask::may_write_gc_heap() -> EffectMask

    EffectMask::may_write_global

    source
    fn EffectMask::may_write_global() -> EffectMask

    EffectMask::may_write_memory

    source
    fn EffectMask::may_write_memory() -> EffectMask

    EffectMask::may_write_table

    source
    fn EffectMask::may_write_table() -> EffectMask

    EffectMask::memory_read

    source
    fn EffectMask::memory_read() -> EffectMask

    EffectMask::memory_write

    source
    fn EffectMask::memory_write() -> EffectMask

    EffectMask::table_read

    source
    fn EffectMask::table_read() -> EffectMask

    EffectMask::table_write

    source
    fn EffectMask::table_write() -> EffectMask

    EffectMask::throw_

    source
    fn EffectMask::throw_() -> EffectMask

    EffectMask::trap

    source
    fn EffectMask::trap() -> EffectMask

    Compatibility conveniences for the pre-freeze API.

    EffectMask::union

    source
    fn EffectMask::union(self : EffectMask, other : EffectMask) -> EffectMask

    EscapeSinkMask

    source
    pub struct EscapeSinkMask(UInt64) derive(Eq, Hash, 
    Debug    )

    EscapeSinkMask::all_known

    source
    fn EscapeSinkMask::all_known() -> EscapeSinkMask

    EscapeSinkMask::bits

    source
    fn EscapeSinkMask::bits(self : EscapeSinkMask) -> UInt64

    EscapeSinkMask::call

    source

    EscapeSinkMask::contains

    source
    fn EscapeSinkMask::contains(self : EscapeSinkMask, other : EscapeSinkMask) -> Bool

    EscapeSinkMask::empty

    source

    EscapeSinkMask::from_bits

    source
    fn EscapeSinkMask::from_bits(bits : UInt64) -> EscapeSinkMask

    EscapeSinkMask::global

    source

    EscapeSinkMask::heap

    source

    EscapeSinkMask::host_unknown

    source
    fn EscapeSinkMask::host_unknown() -> EscapeSinkMask

    EscapeSinkMask::memory

    source

    EscapeSinkMask::return_

    source

    EscapeSinkMask::table

    source

    EscapeSinkMask::throw_

    source

    EscapeSinkMask::union

    source

    ExpressionFact

    source
    pub struct ExpressionFact {
      value : ValueSite
      facts : ValueFacts
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    ExpressionFact::new

    source
    fn ExpressionFact::new(value : ValueSite, facts : ValueFacts, provenance? : SourceProvenance?) -> ExpressionFact

    FactHeapType

    source
    pub enum FactHeapType {
      TypeIndex(UInt)
      Any
      Eq
      Struct
      Array
      I31
      Func
      Extern
      Exn
      Cont
      String
      None
      NoFunc
      NoExtern
      NoExn
      NoCont
    } derive(Eq, Hash, 
    Debug    )

    FactHeapType::any

    source

    FactHeapType::array

    source
    fn FactHeapType::array() -> FactHeapType

    FactHeapType::cont

    source

    FactHeapType::eq

    source

    FactHeapType::exn

    source

    FactHeapType::extern_

    source
    fn FactHeapType::extern_() -> FactHeapType

    FactHeapType::func

    source

    FactHeapType::i31

    source

    FactHeapType::no_cont

    source
    fn FactHeapType::no_cont() -> FactHeapType

    FactHeapType::no_exn

    source
    fn FactHeapType::no_exn() -> FactHeapType

    FactHeapType::no_extern

    source
    fn FactHeapType::no_extern() -> FactHeapType

    FactHeapType::no_func

    source
    fn FactHeapType::no_func() -> FactHeapType

    FactHeapType::none

    source

    FactHeapType::string

    source
    fn FactHeapType::string() -> FactHeapType

    FactHeapType::struct_

    source
    fn FactHeapType::struct_() -> FactHeapType

    FactHeapType::type_index

    source
    fn FactHeapType::type_index(index : UInt) -> FactHeapType

    FactOperand

    source
    pub enum FactOperand {
      ValueOperand(ValueRef)
      ConstantOperand(FactValue)
    } derive(Eq, Hash, 
    Debug    )

    FactOperand::constant

    source
    fn FactOperand::constant(value : FactValue) -> FactOperand

    FactOperand::value

    source
    fn FactOperand::value(value : ValueRef) -> FactOperand

    FactValue

    source
    pub enum FactValue {
      IntegerValue(IntConstant)
      F32Bits(UInt)
      F64Bits(UInt64)
      V128Value(V128Bits)
      RefNullValue(FactHeapType)
      RefFuncValue(UInt)
      ImmutableGlobalValue(UInt)
    } derive(Eq, Hash, 
    Debug    )

    FactValue::f32_bits

    source
    fn FactValue::f32_bits(bits : UInt) -> FactValue

    FactValue::f64_bits

    source
    fn FactValue::f64_bits(bits : UInt64) -> FactValue

    FactValue::immutable_global

    source
    fn FactValue::immutable_global(global : UInt) -> FactValue

    FactValue::integer

    source
    fn FactValue::integer(value : IntConstant) -> FactValue

    FactValue::ref_func

    source
    fn FactValue::ref_func(function : UInt) -> FactValue

    FactValue::ref_null

    source
    fn FactValue::ref_null(heap : FactHeapType) -> FactValue

    FactValue::v128

    source
    fn FactValue::v128(value : V128Bits) -> FactValue

    FieldFacts

    source
    pub struct FieldFacts {
      view : TypeView
      field : UInt
      stored_contents : ValueFacts?
      writes : WriteFacts?
      usage : FieldUsageFacts?
    } derive(Eq, Hash, 
    Debug    )

    FieldFacts::new

    source
    fn FieldFacts::new(view : TypeView, field : UInt, stored_contents? : ValueFacts?, writes? : WriteFacts?, usage? : FieldUsageFacts?) -> FieldFacts

    FieldUsageFacts

    source
    pub struct FieldUsageFacts {
      never_read : Bool
      never_written_after_initialization : Bool
    } derive(Eq, Hash, 
    Debug    )

    FieldUsageFacts::new

    source
    fn FieldUsageFacts::new(never_read? : Bool, never_written_after_initialization? : Bool) -> FieldUsageFacts

    FloatClassMask

    source
    pub struct FloatClassMask(UInt) derive(Eq, Hash, 
    Debug    )

    FloatClassMask::all

    source

    FloatClassMask::bits

    source
    fn FloatClassMask::bits(self : FloatClassMask) -> UInt

    FloatClassMask::contains

    source
    fn FloatClassMask::contains(self : FloatClassMask, other : FloatClassMask) -> Bool

    FloatClassMask::empty

    source

    FloatClassMask::from_bits

    source
    fn FloatClassMask::from_bits(bits : UInt) -> FloatClassMask

    FloatClassMask::nan

    source

    FloatClassMask::negative_infinity

    source
    fn FloatClassMask::negative_infinity() -> FloatClassMask

    FloatClassMask::negative_normal

    source
    fn FloatClassMask::negative_normal() -> FloatClassMask

    FloatClassMask::negative_subnormal

    source
    fn FloatClassMask::negative_subnormal() -> FloatClassMask

    FloatClassMask::negative_zero

    source
    fn FloatClassMask::negative_zero() -> FloatClassMask

    FloatClassMask::positive_infinity

    source
    fn FloatClassMask::positive_infinity() -> FloatClassMask

    FloatClassMask::positive_normal

    source
    fn FloatClassMask::positive_normal() -> FloatClassMask

    FloatClassMask::positive_subnormal

    source
    fn FloatClassMask::positive_subnormal() -> FloatClassMask

    FloatClassMask::positive_zero

    source
    fn FloatClassMask::positive_zero() -> FloatClassMask

    FloatClassMask::union

    source

    FloatFacts

    source
    pub struct FloatFacts {
      width : FloatWidth
      possible_classes : FloatClassMask
    } derive(Eq, Hash, 
    Debug    )

    FloatFacts::new

    source
    fn FloatFacts::new(width : FloatWidth, possible_classes : FloatClassMask) -> FloatFacts

    FloatWidth

    source
    pub enum FloatWidth {
      Float32
      Float64
    } derive(Eq, Hash, 
    Debug    )

    FloatWidth::f32

    source
    fn FloatWidth::f32() -> FloatWidth

    FloatWidth::f64

    source
    fn FloatWidth::f64() -> FloatWidth

    FunctionBodyFacts

    source
    pub struct FunctionBodyFacts {
      function : UInt
      sites : Array[ExpressionFact]
      relations : Array[ScopedRelationFacts]
      calls : Array[CallSiteFacts]
      branches : Array[BranchFacts]
      loops : Array[LoopFacts]
      allocations : Array[AllocationSiteFacts]
      accesses : Array[AccessSiteFacts]
      numeric_operations : Array[NumericOperationSiteFacts]
    } derive(Eq, Hash, 
    Debug    )

    FunctionBodyFacts::new

    source
    fn FunctionBodyFacts::new(function : UInt, sites? : Array[ExpressionFact], relations? : Array[ScopedRelationFacts], calls? : Array[CallSiteFacts], branches? : Array[BranchFacts], loops? : Array[LoopFacts], allocations? : Array[AllocationSiteFacts], accesses? : Array[AccessSiteFacts], numeric_operations? : Array[NumericOperationSiteFacts]) -> FunctionBodyFacts

    FunctionBoundaryFacts

    source
    pub struct FunctionBoundaryFacts {
      all_call_sites_known : Bool
      address_taken : Bool
      host_callable : Bool
    } derive(Eq, Hash, 
    Debug    )

    FunctionBoundaryFacts::new

    source
    fn FunctionBoundaryFacts::new(all_call_sites_known : Bool, address_taken : Bool, host_callable : Bool) -> FunctionBoundaryFacts

    FunctionFacts

    source
    pub struct FunctionFacts {
      function : UInt
      effects : EffectFacts?
      parameters : Array[ParameterFacts]
      results : Array[ResultFacts]
      boundary : FunctionBoundaryFacts?
      profile : FunctionProfile?
      inline_policy : InlinePolicy?
    } derive(Eq, Hash, 
    Debug    )

    FunctionFacts::new

    source
    fn FunctionFacts::new(function : UInt, effects? : EffectFacts?, parameters? : Array[ParameterFacts], results? : Array[ResultFacts], boundary? : FunctionBoundaryFacts?, profile? : FunctionProfile?, inline_policy? : InlinePolicy?) -> FunctionFacts

    FunctionProfile

    source
    pub struct FunctionProfile {
      entry_count : UInt64?
      temperature : TemperatureHint?
    } derive(Eq, Hash, 
    Debug    )

    FunctionProfile::new

    source
    fn FunctionProfile::new(entry_count? : UInt64?, temperature? : TemperatureHint?) -> FunctionProfile

    FunctionResultRef

    source
    pub struct FunctionResultRef {
      function : UInt
      result : UInt
    } derive(Eq, Hash, 
    Debug    )

    FunctionResultRef::new

    source
    fn FunctionResultRef::new(function : UInt, result : UInt) -> FunctionResultRef

    GlobalFacts

    source
    pub struct GlobalFacts {
      global : UInt
      initial_value : ValueFacts?
      steady_state_value : ValueFacts?
      mutation : MutationFacts?
    } derive(Eq, Hash, 
    Debug    )

    GlobalFacts::new

    source
    fn GlobalFacts::new(global : UInt, initial_value? : ValueFacts?, steady_state_value? : ValueFacts?, mutation? : MutationFacts?) -> GlobalFacts

    HeapDomain

    source
    pub enum HeapDomain {
      ExactRuntimeType(FactHeapType)
      SubtypesOf(FactHeapType)
      ClosedRuntimeTypes(ClosedHeapTypeSet)
    } derive(Eq, Hash, 
    Debug    )

    HeapDomain::closed_runtime_types

    source
    fn HeapDomain::closed_runtime_types(types : ClosedHeapTypeSet) -> HeapDomain

    HeapDomain::exact_runtime_type

    source
    fn HeapDomain::exact_runtime_type(type_ : FactHeapType) -> HeapDomain

    HeapDomain::subtypes_of

    source
    fn HeapDomain::subtypes_of(type_ : FactHeapType) -> HeapDomain

    HintTarget

    source
    pub enum HintTarget {
      FunctionHintTarget(UInt)
      SiteHintTarget(CodeSite)
    } derive(Eq, Hash, 
    Debug    )

    HintTarget::function

    source
    fn HintTarget::function(function : UInt) -> HintTarget

    HintTarget::site

    source
    fn HintTarget::site(site : CodeSite) -> HintTarget

    IndexedValueFacts

    source
    pub struct IndexedValueFacts {
      index : UInt
      value : ValueFacts
    } derive(Eq, Hash, 
    Debug    )

    IndexedValueFacts::new

    source
    fn IndexedValueFacts::new(index : UInt, value : ValueFacts) -> IndexedValueFacts

    InlinePolicy

    source
    pub enum InlinePolicy {
      DefaultInlinePolicy
      NeverInline
      PreferInline
      AlwaysInline
    } derive(Eq, Hash, 
    Debug    )

    Profitability hints are never semantic requirements.

    InlinePolicy::always

    source
    fn InlinePolicy::always() -> InlinePolicy

    InlinePolicy::default_

    source
    fn InlinePolicy::default_() -> InlinePolicy

    InlinePolicy::never

    source
    fn InlinePolicy::never() -> InlinePolicy

    InlinePolicy::prefer

    source
    fn InlinePolicy::prefer() -> InlinePolicy

    IntConstant

    source
    pub struct IntConstant {
      width : IntWidth
      bits : UInt64
    } derive(Eq, Hash, 
    Debug    )

    IntConstant::new

    source
    fn IntConstant::new(width : IntWidth, bits : UInt64) -> IntConstant

    IntWidth

    source
    pub enum IntWidth {
      Int8
      Int16
      Int32
      Int64
    } derive(Eq, Hash, 
    Debug    )

    IntWidth::bit_count

    source
    fn IntWidth::bit_count(self : IntWidth) -> UInt

    IntWidth::i16

    source
    fn IntWidth::i16() -> IntWidth

    IntWidth::i32

    source
    fn IntWidth::i32() -> IntWidth

    IntWidth::i64

    source
    fn IntWidth::i64() -> IntWidth

    IntWidth::i8

    source
    fn IntWidth::i8() -> IntWidth

    IntegerFacts

    source
    pub struct IntegerFacts {
      width : IntWidth
      unsigned_range : UnsignedRange?
      signed_range : SignedRange?
      known_bits : KnownBits?
      nonzero : Bool
    } derive(Eq, Hash, 
    Debug    )

    IntegerFacts::new

    source
    fn IntegerFacts::new(width : IntWidth, unsigned_range? : UnsignedRange?, signed_range? : SignedRange?, known_bits? : KnownBits?, nonzero? : Bool) -> IntegerFacts

    KnownBits

    source
    pub struct KnownBits {
      known_zero : UInt64
      known_one : UInt64
    } derive(Eq, Hash, 
    Debug    )

    KnownBits::new

    source
    fn KnownBits::new(known_zero : UInt64, known_one : UInt64) -> KnownBits

    KnownV128Bits

    source
    pub struct KnownV128Bits {
      known_zero : V128Bits
      known_one : V128Bits
    } derive(Eq, Hash, 
    Debug    )

    KnownV128Bits::new

    source
    fn KnownV128Bits::new(known_zero : V128Bits, known_one : V128Bits) -> KnownV128Bits

    LoopFacts

    source
    pub struct LoopFacts {
      site : CodeSite
      profile : LoopProfile?
      temperature : TemperatureHint?
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    LoopFacts::new

    source
    fn LoopFacts::new(site : CodeSite, profile? : LoopProfile?, temperature? : TemperatureHint?, provenance? : SourceProvenance?) -> LoopFacts

    LoopProfile

    source
    pub struct LoopProfile {
      backedge_count : UInt64?
      estimated_trip_count : UInt64?
    } derive(Eq, Hash, 
    Debug    )

    LoopProfile::new

    source
    fn LoopProfile::new(backedge_count? : UInt64?, estimated_trip_count? : UInt64?) -> LoopProfile

    MutationFacts

    source
    pub struct MutationFacts {
      latest_phase : MutationPhase
      sites : Array[CodeSite]?
    } derive(Eq, Hash, 
    Debug    )

    MutationFacts::new

    source
    fn MutationFacts::new(latest_phase : MutationPhase, sites? : Array[CodeSite]?) -> MutationFacts

    MutationPhase

    source
    pub enum MutationPhase {
      NeverMutated
      InitializationOnlyMutation
      RuntimeMutation
    } derive(Eq, Hash, 
    Debug    )

    MutationPhase::initialization_only

    source
    fn MutationPhase::initialization_only() -> MutationPhase

    MutationPhase::never

    source

    MutationPhase::runtime

    source
    fn MutationPhase::runtime() -> MutationPhase

    NullabilityFacts

    source
    pub enum NullabilityFacts {
      NullOnly
      NonNull
    } derive(Eq, Hash, 
    Debug    )

    NullabilityFacts::non_null

    source

    NullabilityFacts::null_only

    source

    NumericOperationFacts

    source
    pub struct NumericOperationFacts {
      signed_no_wrap : Bool
      unsigned_no_wrap : Bool
      exact_division : Bool
    } derive(Eq, Hash, 
    Debug    )

    NumericOperationFacts::new

    source
    fn NumericOperationFacts::new(signed_no_wrap? : Bool, unsigned_no_wrap? : Bool, exact_division? : Bool) -> NumericOperationFacts

    NumericOperationSiteFacts

    source
    pub struct NumericOperationSiteFacts {
      site : ValueSite
      facts : NumericOperationFacts
      provenance : SourceProvenance?
    } derive(Eq, Hash, 
    Debug    )

    NumericOperationSiteFacts::new

    source

    OptimizationFactsBuilder

    source
    pub struct OptimizationFactsBuilder {
      producer : ProducerInfo?
      world : WorldFacts?
      functions : Array[FunctionFacts]
      signatures : Array[SignatureFacts]
      types : Array[TypeFacts]
      globals : Array[GlobalFacts]
      tables : Array[TableFacts]
      bodies : Array[FunctionBodyFacts]
      hints : Array[OptimizationHint]
    } derive(Eq, Hash, 
    Debug    )

    OptimizationFactsBuilder::add_body

    source

    OptimizationFactsBuilder::add_function

    source
    fn OptimizationFactsBuilder::add_function(self : OptimizationFactsBuilder, facts : FunctionFacts) -> Unit

    OptimizationFactsBuilder::add_global

    source
    fn OptimizationFactsBuilder::add_global(self : OptimizationFactsBuilder, facts : GlobalFacts) -> Unit

    OptimizationFactsBuilder::add_hint

    source

    OptimizationFactsBuilder::add_signature

    source
    fn OptimizationFactsBuilder::add_signature(self : OptimizationFactsBuilder, facts : SignatureFacts) -> Unit

    OptimizationFactsBuilder::add_table

    source
    fn OptimizationFactsBuilder::add_table(self : OptimizationFactsBuilder, facts : TableFacts) -> Unit

    OptimizationFactsBuilder::add_type

    source
    fn OptimizationFactsBuilder::add_type(self : OptimizationFactsBuilder, facts : TypeFacts) -> Unit

    OptimizationFactsBuilder::finish

    source

    OptimizationFactsBuilder::new

    source

    OptimizationFactsBuilder::set_producer

    source
    fn OptimizationFactsBuilder::set_producer(self : OptimizationFactsBuilder, producer : ProducerInfo) -> Unit

    OptimizationFactsBuilder::set_world

    source
    fn OptimizationFactsBuilder::set_world(self : OptimizationFactsBuilder, world : WorldFacts) -> Unit

    OptimizationFactsSec

    source
    pub struct OptimizationFactsSec {
      producer : ProducerInfo?
      world : WorldFacts?
      functions : Array[FunctionFacts]
      signatures : Array[SignatureFacts]
      types : Array[TypeFacts]
      globals : Array[GlobalFacts]
      tables : Array[TableFacts]
      bodies : Array[FunctionBodyFacts]
      hints : Array[OptimizationHint]
    } derive(Eq, Hash, 
    Debug    )

    OptimizationFactsSec::new

    source
    fn OptimizationFactsSec::new(producer? : ProducerInfo?, world? : WorldFacts?, functions? : Array[FunctionFacts], signatures? : Array[SignatureFacts], types? : Array[TypeFacts], globals? : Array[GlobalFacts], tables? : Array[TableFacts], bodies? : Array[FunctionBodyFacts], hints? : Array[OptimizationHint]) -> OptimizationFactsSec

    OptimizationGoal

    source
    pub enum OptimizationGoal {
      PreferSpeed
      Balanced
      PreferSize
    } derive(Eq, Hash, 
    Debug    )

    OptimizationGoal::balanced

    source

    OptimizationGoal::prefer_size

    source
    fn OptimizationGoal::prefer_size() -> OptimizationGoal

    OptimizationGoal::prefer_speed

    source
    fn OptimizationGoal::prefer_speed() -> OptimizationGoal

    OptimizationHint

    source
    pub enum OptimizationHint {
      HotnessHint(HintTarget, TemperatureHint)
      InlineHint(HintTarget, InlinePolicy)
      GoalHint(HintTarget, OptimizationGoal)
      BranchProbabilityHint(CodeSite, UInt)
      EstimatedLoopTripsHint(CodeSite, UInt64)
      LikelyCallTargetHint(CodeSite, UInt, UInt)
      LikelyHeapTypeHint(ValueSite, FactHeapType, UInt)
    } derive(Eq, Hash, 
    Debug    )

    Probability and confidence values use the inclusive integer domain 0..65535.

    OptimizationHint::branch_probability

    source
    fn OptimizationHint::branch_probability(site : CodeSite, probability : UInt) -> OptimizationHint

    OptimizationHint::estimated_loop_trips

    source
    fn OptimizationHint::estimated_loop_trips(site : CodeSite, trips : UInt64) -> OptimizationHint

    OptimizationHint::goal

    source

    OptimizationHint::hotness

    source
    fn OptimizationHint::hotness(target : HintTarget, temperature : TemperatureHint) -> OptimizationHint

    OptimizationHint::inline_

    source
    fn OptimizationHint::inline_(target : HintTarget, policy : InlinePolicy) -> OptimizationHint

    OptimizationHint::likely_call_target

    source
    fn OptimizationHint::likely_call_target(site : CodeSite, function : UInt, confidence : UInt) -> OptimizationHint

    OptimizationHint::likely_heap_type

    source
    fn OptimizationHint::likely_heap_type(site : ValueSite, type_ : FactHeapType, confidence : UInt) -> OptimizationHint

    ParameterFacts

    source
    pub struct ParameterFacts {
      parameter : UInt
      value : ValueFacts?
      uses : ParameterUseMask?
      escape_sinks : EscapeSinkMask?
    } derive(Eq, Hash, 
    Debug    )

    ParameterFacts::new

    source
    fn ParameterFacts::new(parameter : UInt, value? : ValueFacts?, uses? : ParameterUseMask?, escape_sinks? : EscapeSinkMask?) -> ParameterFacts

    ParameterRef

    source
    pub struct ParameterRef {
      function : UInt
      parameter : UInt
    } derive(Eq, Hash, 
    Debug    )

    ParameterRef::new

    source
    fn ParameterRef::new(function : UInt, parameter : UInt) -> ParameterRef

    ParameterUseMask

    source
    pub struct ParameterUseMask(UInt64) derive(Eq, Hash, 
    Debug    )

    ParameterUseMask::address_index

    source
    fn ParameterUseMask::address_index() -> ParameterUseMask

    ParameterUseMask::all_known

    source

    ParameterUseMask::bits

    source
    fn ParameterUseMask::bits(self : ParameterUseMask) -> UInt64

    ParameterUseMask::call_argument

    source
    fn ParameterUseMask::call_argument() -> ParameterUseMask

    ParameterUseMask::contains

    source
    fn ParameterUseMask::contains(self : ParameterUseMask, other : ParameterUseMask) -> Bool

    ParameterUseMask::control

    source

    ParameterUseMask::direct_computation

    source
    fn ParameterUseMask::direct_computation() -> ParameterUseMask

    ParameterUseMask::empty

    source

    ParameterUseMask::from_bits

    source
    fn ParameterUseMask::from_bits(bits : UInt64) -> ParameterUseMask

    ParameterUseMask::identity_observing

    source
    fn ParameterUseMask::identity_observing() -> ParameterUseMask

    ParameterUseMask::return_

    source

    ParameterUseMask::stored_value

    source
    fn ParameterUseMask::stored_value() -> ParameterUseMask

    ParameterUseMask::union

    source

    ProducerInfo

    source
    pub struct ProducerInfo {
      name : String
      version : String
      build_id : String?
    } derive(Eq, Hash, 
    Debug    )

    ProducerInfo::new

    source
    fn ProducerInfo::new(name : String, version : String, build_id? : String?) -> ProducerInfo

    ReferenceFacts

    source
    pub struct ReferenceFacts {
      nullability : NullabilityFacts?
      heap : HeapDomain?
      function_targets : ClosedFunctionSet?
    } derive(Eq, Hash, 
    Debug    )

    ReferenceFacts::new

    source
    fn ReferenceFacts::new(nullability? : NullabilityFacts?, heap? : HeapDomain?, function_targets? : ClosedFunctionSet?) -> ReferenceFacts

    RelationKind

    source
    pub enum RelationKind {
      Equal
      NotEqual
      SignedLessThan
      SignedLessOrEqual
      UnsignedLessThan
      UnsignedLessOrEqual
      SameReference
      DistinctReferences
    } derive(Eq, Hash, 
    Debug    )

    RelationKind::distinct_references

    source
    fn RelationKind::distinct_references() -> RelationKind

    RelationKind::equal

    source
    fn RelationKind::equal() -> RelationKind

    RelationKind::not_equal

    source
    fn RelationKind::not_equal() -> RelationKind

    RelationKind::same_reference

    source
    fn RelationKind::same_reference() -> RelationKind

    RelationKind::signed_less_or_equal

    source
    fn RelationKind::signed_less_or_equal() -> RelationKind

    RelationKind::signed_less_than

    source
    fn RelationKind::signed_less_than() -> RelationKind

    RelationKind::unsigned_less_or_equal

    source
    fn RelationKind::unsigned_less_or_equal() -> RelationKind

    RelationKind::unsigned_less_than

    source
    fn RelationKind::unsigned_less_than() -> RelationKind

    ResultFacts

    source
    pub struct ResultFacts {
      result : UInt
      value : ValueFacts?
      identity : ResultIdentityFacts?
    } derive(Eq, Hash, 
    Debug    )

    ResultFacts::new

    source
    fn ResultFacts::new(result : UInt, value? : ValueFacts?, identity? : ResultIdentityFacts?) -> ResultFacts

    ResultIdentityFacts

    source
    pub enum ResultIdentityFacts {
      FreshReference
      ClosedAliases(ClosedAliasSet)
    } derive(Eq, Hash, 
    Debug    )

    ResultIdentityFacts::closed_aliases

    source
    fn ResultIdentityFacts::closed_aliases(aliases : ClosedAliasSet) -> ResultIdentityFacts

    ResultIdentityFacts::fresh

    source

    ResultIdentityFacts::same_as_global

    source
    fn ResultIdentityFacts::same_as_global(global : UInt) -> ResultIdentityFacts

    ResultIdentityFacts::same_as_parameter

    source
    fn ResultIdentityFacts::same_as_parameter(parameter : UInt) -> ResultIdentityFacts

    ScopedRelationFacts

    source
    pub struct ScopedRelationFacts {
      at : CodeSite
      left : FactOperand
      kind : RelationKind
      right : FactOperand
    } derive(Eq, Hash, 
    Debug    )

    ScopedRelationFacts::new

    source

    SignatureFacts

    source
    pub struct SignatureFacts {
      signature : UInt
      parameters : Array[IndexedValueFacts]
      results : Array[IndexedValueFacts]
      call_sites_complete : Bool
    } derive(Eq, Hash, 
    Debug    )

    SignatureFacts::new

    source
    fn SignatureFacts::new(signature : UInt, parameters? : Array[IndexedValueFacts], results? : Array[IndexedValueFacts], call_sites_complete? : Bool) -> SignatureFacts

    SignedRange

    source
    pub struct SignedRange {
      min : Int64
      max : Int64
    } derive(Eq, Hash, 
    Debug    )

    SignedRange::new

    source
    fn SignedRange::new(min : Int64, max : Int64) -> SignedRange

    SourceProvenance

    source
    pub struct SourceProvenance {
      module_id : UInt64?
      declaration_id : UInt64?
      body_id : UInt64?
      expression_id : UInt64?
      source_offset : UInt64?
      specialization_id : UInt64?
    } derive(Eq, Hash, 
    Debug    )

    SourceProvenance::new

    source
    fn SourceProvenance::new(module_id? : UInt64?, declaration_id? : UInt64?, body_id? : UInt64?, expression_id? : UInt64?, source_offset? : UInt64?, specialization_id? : UInt64?) -> SourceProvenance

    TableEntryFacts

    source
    pub struct TableEntryFacts {
      index : UInt64
      value : ReferenceFacts
    } derive(Eq, Hash, 
    Debug    )

    TableEntryFacts::new

    source
    fn TableEntryFacts::new(index : UInt64, value : ReferenceFacts) -> TableEntryFacts

    TableFacts

    source
    pub struct TableFacts {
      table : UInt
      mutation : MutationFacts?
      may_grow : Bool?
      default_value : ReferenceFacts?
      entries : Array[TableEntryFacts]
      contents_complete : Bool
    } derive(Eq, Hash, 
    Debug    )

    TableFacts::new

    source
    fn TableFacts::new(table : UInt, mutation? : MutationFacts?, may_grow? : Bool?, default_value? : ReferenceFacts?, entries? : Array[TableEntryFacts], contents_complete? : Bool) -> TableFacts

    TemperatureHint

    source
    pub enum TemperatureHint {
      Cold
      Normal
      Hot
    } derive(Eq, Hash, 
    Debug    )

    TemperatureHint::cold

    source

    TemperatureHint::hot

    source

    TemperatureHint::normal

    source

    TypeFacts

    source
    pub struct TypeFacts {
      type_ : UInt
      population : TypePopulation?
      fields : Array[FieldFacts]
      array_element : ArrayElementFacts?
    } derive(Eq, Hash, 
    Debug    )

    TypeFacts::new

    source
    fn TypeFacts::new(type_ : UInt, population? : TypePopulation?, fields? : Array[FieldFacts], array_element? : ArrayElementFacts?) -> TypeFacts

    TypePopulation

    source
    pub enum TypePopulation {
      EmptyTypePopulation
      ClosedTypePopulation(ClosedHeapTypeSet)
    } derive(Eq, Hash, 
    Debug    )

    TypePopulation::closed

    source

    TypePopulation::empty

    source

    TypeView

    source
    pub enum TypeView {
      ExactTypeView(UInt)
      SubtypeClosureView(UInt)
    } derive(Eq, Hash, 
    Debug    )

    TypeView::exact

    source
    fn TypeView::exact(type_ : UInt) -> TypeView

    TypeView::subtype_closure

    source
    fn TypeView::subtype_closure(type_ : UInt) -> TypeView

    UnsignedRange

    source
    pub struct UnsignedRange {
      min : UInt64
      max : UInt64
    } derive(Eq, Hash, 
    Debug    )

    UnsignedRange::new

    source
    fn UnsignedRange::new(min : UInt64, max : UInt64) -> UnsignedRange

    V128Bits

    source
    pub struct V128Bits {
      low : UInt64
      high : UInt64
    } derive(Eq, Hash, 
    Debug    )

    V128Bits::new

    source
    fn V128Bits::new(low : UInt64, high : UInt64) -> V128Bits

    ValueFacts

    source
    pub struct ValueFacts {
      possible_values : ClosedValueSet?
      integer : IntegerFacts?
      float_ : FloatFacts?
      vector : VectorFacts?
      reference : ReferenceFacts?
    } derive(Eq, Hash, 
    Debug    )

    ValueFacts::exact_ref_func

    source
    fn ValueFacts::exact_ref_func(function : UInt) -> ValueFacts

    ValueFacts::exact_value

    source
    fn ValueFacts::exact_value(value : FactValue) -> ValueFacts

    ValueFacts::impossible

    source
    fn ValueFacts::impossible() -> ValueFacts

    ValueFacts::new

    source
    fn ValueFacts::new(possible_values? : ClosedValueSet?, integer? : IntegerFacts?, float_? : FloatFacts?, vector? : VectorFacts?, reference? : ReferenceFacts?) -> ValueFacts

    ValueFacts::nonnull

    source
    fn ValueFacts::nonnull() -> ValueFacts

    ValueFacts::nonnull_exact_ref

    source
    fn ValueFacts::nonnull_exact_ref(heap : FactHeapType) -> ValueFacts

    ValueFacts::signed_range

    source
    fn ValueFacts::signed_range(min : Int64, max : Int64, width? : IntWidth) -> ValueFacts

    ValueFacts::unknown

    source
    fn ValueFacts::unknown() -> ValueFacts

    ValueFacts::unsigned_range

    source
    fn ValueFacts::unsigned_range(min : UInt64, max : UInt64, width? : IntWidth) -> ValueFacts

    ValueRef

    source
    pub enum ValueRef {
      SiteValue(ValueSite)
      ParameterValue(ParameterRef)
      FunctionResultValue(FunctionResultRef)
      GlobalValue(UInt)
    } derive(Eq, Hash, 
    Debug    )

    ValueRef::function_result

    source
    fn ValueRef::function_result(result : FunctionResultRef) -> ValueRef

    ValueRef::global

    source
    fn ValueRef::global(global : UInt) -> ValueRef

    ValueRef::parameter

    source
    fn ValueRef::parameter(parameter : ParameterRef) -> ValueRef

    ValueRef::site

    source
    fn ValueRef::site(site : ValueSite) -> ValueRef

    ValueSite

    source
    pub struct ValueSite {
      site : CodeSite
      result : UInt
    } derive(Eq, Hash, 
    Debug    )

    ValueSite::new

    source
    fn ValueSite::new(site : CodeSite, result? : UInt) -> ValueSite

    VectorFacts

    source
    pub struct VectorFacts {
      known_bits : KnownV128Bits?
      splat : FactValue?
      lane_shape : VectorLaneShape?
    } derive(Eq, Hash, 
    Debug    )

    VectorFacts::new

    source
    fn VectorFacts::new(known_bits? : KnownV128Bits?, splat? : FactValue?, lane_shape? : VectorLaneShape?) -> VectorFacts

    VectorLaneShape

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

    VectorLaneShape::f32x4

    source

    VectorLaneShape::f64x2

    source

    VectorLaneShape::i16x8

    source

    VectorLaneShape::i32x4

    source

    VectorLaneShape::i64x2

    source

    VectorLaneShape::i8x16

    source

    WorldFacts

    source
    pub struct WorldFacts {
      mode : WorldMode
      host_can_call_exports : Bool
      host_can_mutate_exported_state : Bool
    } derive(Eq, Hash, 
    Debug    )

    WorldFacts::closed_module

    source
    fn WorldFacts::closed_module(host_can_call_exports? : Bool, host_can_mutate_exported_state? : Bool) -> WorldFacts

    WorldFacts::closed_program

    source
    fn WorldFacts::closed_program(host_can_call_exports? : Bool, host_can_mutate_exported_state? : Bool) -> WorldFacts

    WorldFacts::new

    source
    fn WorldFacts::new(mode : WorldMode, host_can_call_exports : Bool, host_can_mutate_exported_state : Bool) -> WorldFacts

    WorldFacts::open_world

    source
    fn WorldFacts::open_world(host_can_call_exports? : Bool, host_can_mutate_exported_state? : Bool) -> WorldFacts

    WorldMode

    source
    pub enum WorldMode {
      OpenWorld
      ClosedModule
      ClosedProgram
    } derive(Eq, Hash, 
    Debug    )

    WorldMode::closed_module

    source
    fn WorldMode::closed_module() -> WorldMode

    WorldMode::closed_program

    source
    fn WorldMode::closed_program() -> WorldMode

    WorldMode::open_world

    source
    fn WorldMode::open_world() -> WorldMode

    WriteFacts

    source
    pub enum WriteFacts {
      NoWrites
      InitializationOnly
      ClosedWrites(Array[CodeSite])
    } derive(Eq, Hash, 
    Debug    )

    WriteFacts::closed

    source
    fn WriteFacts::closed(sites : Array[CodeSite]) -> WriteFacts

    WriteFacts::initialization_only

    source
    fn WriteFacts::initialization_only() -> WriteFacts

    WriteFacts::no_writes

    source
    fn WriteFacts::no_writes() -> WriteFacts

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io