🥮 mooncakes.io

    #src/ir

    IR2 owns exactly one optimizer body representation: HotFunc.

    #Ownership Rules

    • Boundary decode, encode, validation, printing, and debug-module views stay on raw @lib.Module / @lib.Expr forms.
    • HotFunc is the only owned optimizer body representation.
    • CFG, dominance, post-dominance, liveness, use-def, effects, loop info, and SSA are derived overlays keyed by revision; they do not own bodies.
    • Semantic mutation must go through public hot-IR mutation APIs and must bump revision.
    • There is no compatibility surface for deleted recursive optimizer-body ownership layers.

    #Pass Contract

    • Pipeline shape: lift -> verify -> analyze -> mutate -> verify -> lower.
    • Pass descriptors must declare required analyses and invalidations.
    • Every later IR2 slice follows strict TDD: add/adjust failing tests first, then implement, then rerun moon test.

    #Canonical Docs

    #Module Map

    • architecture.mbt: shared IR2 architecture types that later pass-manager slices build on now, including revision reads and pass-descriptor metadata.
    • bitset.mbt: shared dense UInt64-backed mutable bitsets with strict bounds checks, in-place set algebra, and deterministic set-bit iteration for later dataflow overlays.
    • cfg.mbt: deterministic CFG overlay builder with synthetic entry/exit blocks, explicit edge lists, node and region-root block mappings, structured label-target resolution, and exceptional-exit tracking for later dominator and dataflow slices.
    • cfg_contract.mbt: normative block-boundary, structured-control successor, terminator edge-kind, and exceptional-edge policy helpers so CFG construction and later analyses stop guessing hot-IR control-flow rules.
    • cfg_order.mbt: shared deterministic CFG preorder/postorder/reverse-postorder helpers, reverse-exit traversals, exceptional-edge-inclusive order variants, direct-region block ordering, and worklist seed policy so later analyses stop reimplementing block visitation order and unreachable-block handling.
    • dominators.mbt: reachable-block dominator overlay with immediate dominators, dominator-tree children, dominance frontiers, interval-based dominance queries, and a debug dump surface built over the normal-flow CFG edge policy.
    • effects.mbt: conservative derived effect-mask summaries for nodes, blocks, and regions, combining raw hot flags with exact-instruction refinement, including SIMD memory and string array effects, so passes can ask purity, memory, throw, trap, and state-behavior questions through one shared API.
    • liveness.mbt: locals-only backward dataflow overlay with block live_in / live_out bitsets and direct local liveness queries, using the current non-exceptional CFG edge policy so SSA v1 stays aligned with normal-flow dominance.
    • loop_info.mbt: natural-loop overlay with loop headers, loop bodies, latch sets, exit edges, parent nesting, block depths, block-to-innermost-loop mapping, and a debug dump surface built from CFG plus dominance.
    • postdominators.mbt: reverse-flow post-dominator overlay with explicit normal and exceptional exit roots, immediate post-dominators, post-dominator-tree children, post-dominance frontiers, interval-free post-dominance queries, and a debug dump surface for later control rewrites.
    • analysis_cache.mbt: shared revision-keyed cache entries for CFG, traversal orders, dominators, post-dominators, loop info, use-def, liveness, effects, and local SSA, with typed get_or_build helpers and explicit cache reset for pass pipelines.
    • ssa_policy.mbt: local SSA overlay policy helpers covering SSA value and phi ids, entry-definition origins, overlay-only phi ownership, pruned dominance-frontier phi placement, and the locked rename/destruction/exclusion rules for SSA v1.
    • ssa_local.mbt: local SSA construction overlay with synthetic entry defs, block-entry phi placement/materialization, dominator-tree renaming for LocalGet / LocalSet / LocalTee, predecessor-aligned phi inputs, and direct def/use query helpers for later SSA-assisted rewrites.
    • ssa_destroy.mbt: local SSA destruction helpers that assign concrete locals, insert predecessor copies for block-entry phis, allocate temp locals for cyclic parallel copies, rewrite local ops back to plain hot locals, and drop dead local defs created by destruction.
    • test_helpers.mbt: shared IR2 fixture builders, verify-and-lower assertions, and deterministic CFG / dominance / liveness / SSA dump helpers for adjacent golden tests.
    • use_def.mbt: node-use and locals-only block def/use overlay with distinct root-slot vs child-slot tracking, local read/write node queries, and CFG-ordered per-block summaries for later liveness, DCE, and SSA work.
    • hot_core.mbt: owned dense storage model, storage counters, body-result accessors, and the minimal core debug dump surface. Deleted nodes are tracked as tombstones, and free-list reuse remains disabled for now.
    • hot_flags.mbt: canonical per-op raw flag table plus fast node classification helpers for control, branch, effect, trap, and exceptional-edge queries, including the conservative Heap family contract for GC/reference boundary ops that still preserve exact opcode identity through payload side tables.
    • hot_types.mbt: canonical keyed type interning plus result-arity, result-type, and local-metadata queries for later label, CFG, and SSA slices.
    • hot_labels.mbt: stable label ownership, branch-arity, and control-region slot metadata so later analyses stop decoding control immediates directly.
    • hot_side_tables.mbt: typed side-table alloc/get helpers for const payloads, memargs, branch tables, catches, call signatures, and exact boundary instruction payloads; branch and catch arrays are copied on construction, allocation, and access so retained payload objects cannot mutate cached control flow without a revision bump.
    • hot_builders.mbt: canonical safe node constructors that allocate labels, region wrappers, and side-table payload ids without raw field assembly, including the Heap family helper used for boundary GC/reference instructions.
    • hot_mutate.mbt: canonical root, node, child-span, deletion, and revision-bump mutation helpers so later rewrites stop writing HotFunc storage directly.
    • hot_query.mbt: canonical read-only node-family, exact-instruction, type, branch, simple-value, single-root wrapper, wrapper-body unwrap, single-if, plain-branch arm, trailing-plain-branch split, single-exit arm, holder-block, repeated-root / repeated-child, repeated-wrapper, trailing-payload-split, span, local-metadata, and tombstone queries so analyses and passes stop decoding raw storage layout directly.
    • hot_walk.mbt: stable root, child, subtree, region, control-region, worklist, and rewrite-by-slot traversal helpers with explicit Continue / Skip / Stop / Error control flow.
    • hot_region_edit.mbt: one structured region reference plus root/body/then/else/catch splice helpers so passes can rewrite top-level and nested bodies through one mutation contract.
    • hot_module_context.mbt: shared boundary-module context resolution for function signatures, type-index block results, memories, tables, globals, tags, element segments, data segments, and aggregate field metadata so lift/lower and later analyses stop depending on validator-private lookups.
    • hot_verify.mbt: structured core/control verification plus CFG, dominator, post-dominator, liveness, and SSA hooks plus debug abort helpers so lift/lower and later passes fail fast on corruption.
    • hot_lift.mbt: validator-backed boundary-to-hot lifting for function bodies and module functions, including module-context resolution, label metadata allocation, typed side-table payload preservation, and structured lift errors.
    • hot_lower.mbt: verified hot-to-boundary lowering for function bodies and @lib.Func definitions, including label-depth remapping, exact-instruction recovery, and stack-aware emission for shared branch payload values.
    • hot.mbt: compatibility-free hot-lift/lower façade helpers and glue used by active IR2 consumers.
    • float_compat.mbt: Wasm-compatible float helper surface used by hot lifting/lowering.

    #Split Rule

    The split is now landed, not just planned. Later slices should keep adding focused modules or extending the current focused owners instead of growing hot.mbt back into a monolith. Treat hot.mbt as a compatibility-free facade/glue layer over the focused files above.

    BlockId

    source
    type BlockId = Int

    EffectMask

    source
    type EffectMask = UInt

    LabelId

    source
    type LabelId = Int

    LocalId

    source
    type LocalId = Int

    NodeId

    source
    type NodeId = Int

    PhiId

    source
    type PhiId = Int

    RootId

    source
    type RootId = Int

    SideTableId

    source
    type SideTableId = Int

    SsaValueId

    source
    type SsaValueId = Int

    TypeId

    source
    type TypeId = Int

    Bitset

    source
    pub struct Bitset {
      size : Int
      words : Array[UInt64]
    } derive(Eq, 
    Debug    )

    CfgBlockBoundaryReason

    source
    pub enum CfgBlockBoundaryReason {
      RootEntry
      ControlHeader
      LoopHeader
      BodyRegionEntry
      ThenRegionEntry
      ElseRegionEntry
      CatchRegionEntry
      CatchListRegionEntry
      Terminator
    } derive(Eq, 
    Debug    )

    CfgControlSuccessorPolicy

    source
    pub enum CfgControlSuccessorPolicy {
      InlineBodyRegion
      SplitThenElse
      SplitBodyCatch
      SplitBodyCatchList
    } derive(Eq, 
    Debug    )

    CfgEdge

    source
    pub struct CfgEdge {
      kind : CfgEdgeKind
      block : Int
    } derive(Eq, 
    Debug    )

    impl Show for CfgEdge

    CfgEdgeKind

    source
    pub enum CfgEdgeKind {
      FallthroughEdge
      BranchEdge
      ReturnEdge
      ExceptionalEdge
      UnreachableExitEdge
    } derive(Eq, 
    Debug    )

    impl Show for CfgEdgeKind

    CfgExceptionTargetPolicy

    source
    pub enum CfgExceptionTargetPolicy {
      NoExceptionEdge
      PropagateToCaller
      ToCatchRegion
      ToCatchListRegion
      DelegateToTarget
    } derive(Eq, 
    Debug    )

    CfgRegionRootBlock

    source
    pub struct CfgRegionRootBlock {
      region_holder : Int
      slot : Int
      block : Int
    } derive(Eq, 
    Debug    )

    HotAnalysis

    source
    pub enum HotAnalysis {
      Cfg
      Dominance
      Liveness
      UseDef
      Effects
      LoopInfo
      Ssa
    } derive(Eq, 
    Debug    )

    impl Show for HotAnalysis

    HotAnalysis::cfg

    source

    HotAnalysis::dominance

    source
    fn HotAnalysis::dominance() -> HotAnalysis

    HotAnalysis::effects

    source
    fn HotAnalysis::effects() -> HotAnalysis

    HotAnalysis::liveness

    source
    fn HotAnalysis::liveness() -> HotAnalysis

    HotAnalysis::loop_info

    source
    fn HotAnalysis::loop_info() -> HotAnalysis

    HotAnalysis::ssa

    source

    HotAnalysis::use_def

    source
    fn HotAnalysis::use_def() -> HotAnalysis

    HotAnalysisCache

    source
    pub struct HotAnalysisCache {
      owner_roots : Array[Int]?
      cfg : HotCacheEntry[HotCfg]?
      orders : HotCacheEntry[HotCfgOrders]?
      dom : HotCacheEntry[HotDominators]?
      postdom : HotCacheEntry[HotPostDominators]?
      loop_info : HotCacheEntry[HotLoopInfo]?
      use_def : HotCacheEntry[HotUseDef]?
      liveness : HotCacheEntry[HotLiveness]?
      effects : HotCacheEntry[HotEffectsSummary]?
      ssa : HotCacheEntry[HotLocalSsa]?
    } derive(Eq, 
    Debug    )

    HotAnalysisCache::new

    source

    HotBlockInfo

    source
    pub struct HotBlockInfo {
      id : Int
      nodes : Array[Int]
      preds : Array[CfgEdge]
      succs : Array[CfgEdge]
      is_synthetic : Bool
      region_holder : Int
      start_slot : Int
      end_slot : Int
    } derive(Eq, 
    Debug    )

    HotBranchTable

    source
    pub struct HotBranchTable {
      targets : Array[Int]
      default_target : Int
    } derive(Eq, 
    Debug    )

    HotBranchTable::new

    source
    fn HotBranchTable::new(targets : Array[Int], default_target : Int) -> HotBranchTable

    HotCacheEntry

    source
    pub struct HotCacheEntry[T] {
      built_at_revision : Int
      value : T
    } derive(Eq, 
    Debug    )

    impl Show for HotCacheEntry[T]

    HotCallSig

    source

    impl Show for HotCallSig

    HotCallSig::new

    source

    HotCatchArm

    source
    pub enum HotCatchArm {
      CatchArm(
    TagIdx    , Int)
      CatchRefArm(
    TagIdx    , Int)
      CatchAllArm(Int)
      CatchAllRefArm(Int)
    } derive(Eq, 
    Debug    )

    impl Show for HotCatchArm

    HotCatchArm::all

    source
    fn HotCatchArm::all(label_id : Int) -> HotCatchArm

    HotCatchArm::all_ref

    source
    fn HotCatchArm::all_ref(label_id : Int) -> HotCatchArm

    HotCatchArm::catch_

    source
    fn HotCatchArm::catch_(tag_idx : 
    TagIdx    , label_id : Int) -> HotCatchArm

    HotCatchArm::catch_ref

    source
    fn HotCatchArm::catch_ref(tag_idx : 
    TagIdx    , label_id : Int) -> HotCatchArm

    HotCatchInfo

    source
    pub struct HotCatchInfo {
      catches : Array[HotCatchArm]
    } derive(Eq, 
    Debug    )

    HotCatchInfo::new

    source

    HotCfg

    source
    pub struct HotCfg {
      operands_expanded : Bool
      blocks : Array[HotBlockInfo]
      node_to_block : Array[Int]
      region_roots : Array[CfgRegionRootBlock]
      entry_block : Int
      exit_block : Int
      exceptional_exit_block : Int?
    } derive(Eq, 
    Debug    )

    impl Show for HotCfg

    HotCfgOrders

    source
    pub struct HotCfgOrders {
      preorder : Array[Int]
      postorder : Array[Int]
      reverse_postorder : Array[Int]
      reverse_postorder_with_exceptions : Array[Int]
      reverse_exit_postorder : Array[Int]
      reverse_exit_postorder_with_exceptions : Array[Int]
      worklist_seed : Array[Int]
    } derive(Eq, 
    Debug    )

    HotChildSpanRewrite

    source
    pub struct HotChildSpanRewrite {
      node_id : Int
      new_children : Array[Int]
    } derive(Eq, 
    Debug    )

    HotChildSpanRewrite::new

    source
    fn HotChildSpanRewrite::new(node_id : Int, new_children : Array[Int]) -> HotChildSpanRewrite

    HotConstPayload

    source

    HotConstPayload::f32_const

    source

    HotConstPayload::f64_const

    source

    HotConstPayload::i32_const

    source

    HotConstPayload::i64_const

    source

    HotConstPayload::ref_null_const

    source

    HotConstPayload::string_const

    source
    fn HotConstPayload::string_const(value : Bytes) -> HotConstPayload

    HotControlRegionRole

    source
    pub enum HotControlRegionRole {
      BodyRegion
      ThenRegion
      ElseRegion
      CatchRegion
      CatchListRegion
    } derive(Eq, 
    Debug    )

    HotControlRegionSlotInfo

    source
    pub struct HotControlRegionSlotInfo {
      slot : Int
      role : HotControlRegionRole
      required : Bool
    } derive(Eq, 
    Debug    )

    HotDominators

    source
    pub struct HotDominators {
      entry_block : Int
      reachable : Bitset
      idoms : Array[Int]
      children : Array[Array[Int]]
      frontiers : Array[Array[Int]]
      dom_preorder : Array[Int]
      dom_postorder : Array[Int]
    } derive(Eq, 
    Debug    )

    HotEffectsSummary

    source
    pub struct HotEffectsSummary {
      node_masks : Array[UInt]
      block_masks : Array[UInt]
      root_region_mask : UInt
    } derive(Eq, 
    Debug    )

    HotFunc

    source
    pub struct HotFunc {
      nodes : Array[HotNode]
      children : Array[Int]
      roots : Array[Int]
      locals : HotLocals
      types : Array[HotTypeInfo]
      type_ids : 
    HashMap    [String, Int]
      value_types : Array[
    ValType    ]
      value_type_ids : Array[Int]
      block_types : Array[
    BlockType    ]
      block_type_ids : Array[Int]
      labels : Array[HotLabelInfo]
      consts : Array[HotConstPayload]
      memargs : Array[HotMemArg]
      branch_tables : Array[HotBranchTable]
      catches : Array[HotCatchInfo]
      call_sigs : Array[HotCallSig]
      instr_payloads : Array[HotInstrPayload]
      body_result_type : Int
      func_type_idx : 
    TypeIdx    ?
      free_nodes : Array[Int]
      deleted_nodes : Array[Bool]
      revision : Int
      validation_env : 
    Env    ?
      lifted_local_accesses : HotLiftLocalAccesses?
    }

    HotFunc::new

    source
    fn HotFunc::new(locals? : HotLocals, body_result_type? : Int) -> HotFunc

    HotInstrPayload

    source

    HotInstrPayload::new

    source

    HotLabelInfo

    source
    pub struct HotLabelInfo {
      kind : HotLabelKind
      result_type : Int
      owner : Int
      branch_arity : Int
    } derive(Eq, 
    Debug    )

    HotLabelKind

    source
    pub enum HotLabelKind {
      BlockLabel
      LoopLabel
      IfLabel
      RegionLabel
      TryLabel
      TryTableLabel
    } derive(Eq, 
    Debug    )

    HotLiftError

    source
    pub enum HotLiftError {
      InvalidLabelDepth(Int)
      InvalidFunctionIndex(
    FuncIdx    )
      MissingFunctionBody(
    FuncIdx    )
      MissingFunctionType(
    FuncIdx    )
      InvalidBodyState(String)
      TypecheckFailure(String, String)
      UnsupportedInstruction(String)
    } derive(Eq, 
    Debug    )

    HotLiftLocalAccesses

    source
    pub struct HotLiftLocalAccesses {
      local_count : Int
      gets : Array[(Int, Int)]
      writes : Array[(Int, Int)]
      capture_sources : Array[(Int, Int)]?
      revision : Int
    }

    Source-order local accesses from an unmodified lift. A missing node (-1) denotes a stack-polymorphic instruction with no concrete operand. Synthetic lifetime captures have no source entry. Raw rewriters must use this map, rather than assuming that HOT node order equals raw instruction order.

    HotLiveness

    source
    pub struct HotLiveness {
      include_exceptional_edges : Bool
      live_in_sets : Array[Bitset]
      live_out_sets : Array[Bitset]
    } derive(Eq, 
    Debug    )

    impl Show for HotLiveness

    HotLocalGraph

    source
    pub struct HotLocalGraph {
      local_count : Int
      param_count : Int
      get_source_ids : Array[Array[Int]]
      set_influence_gets : Array[Array[Int]]
      write_local_ids : Array[Int]
      write_is_tees : Array[Bool]
      local_is_already_ssa : Array[Bool]
      local_has_legal_default : Array[Bool]
    } derive(Eq, 
    Debug    )

    HotLocalGraphSource

    source
    pub enum HotLocalGraphSource {
      EntrySource(Int)
      SetSource(Int)
    } derive(Eq, 
    Debug    )

    HotLocalGraphSourceValue

    source
    pub struct HotLocalGraphSourceValue {
      is_entry : Bool
      index : Int
    } derive(Eq, 
    Debug    )

    Scalar source description for allocation-free indexed queries. Entry indices identify locals; other indices identify write nodes. No graph storage or encoded source identity escapes through this value.

    HotLocalReadSources

    source
    pub struct HotLocalReadSources {
      // private fields
    } derive(
    Debug    )

    Immutable reaching-read sources, without writer influences or SSA facts. A zero source count remains unknown; consumers must keep their fallback.

    HotLocalSsa

    source
    pub struct HotLocalSsa {
      revision : Int
      value_types : Array[
    ValType    ]
      value_origins : Array[HotSsaValueOrigin]
      phis : Array[HotSsaPhi]
      entry_defs : Array[Int]
      phi_value_ids : Array[Int]
      block_phis : Array[Array[Int]]
      phi_inputs : Array[Array[HotSsaPhiInput]]
      local_get_values : Array[Int]
      local_write_defs : Array[Int]
      value_uses : Array[Array[HotSsaUseOrigin]]
    } derive(Eq, 
    Debug    )

    impl Show for HotLocalSsa

    HotLocalSsa::new

    source
    fn HotLocalSsa::new(revision? : Int, value_types? : Array[
    ValType    ], value_origins? : Array[HotSsaValueOrigin], phis? : Array[HotSsaPhi], entry_defs? : Array[Int], phi_value_ids? : Array[Int], block_phis? : Array[Array[Int]], phi_inputs? : Array[Array[HotSsaPhiInput]], local_get_values? : Array[Int], local_write_defs? : Array[Int], value_uses? : Array[Array[HotSsaUseOrigin]]) -> HotLocalSsa

    HotLocals

    source

    impl Show for HotLocals

    HotLocals::new

    source

    HotLoopExit

    source
    pub struct HotLoopExit {
      from : Int
      edge : CfgEdge
    } derive(Eq, 
    Debug    )

    impl Show for HotLoopExit

    HotLoopInfo

    source
    pub struct HotLoopInfo {
      loops : Array[HotLoopSummary]
      block_to_loop : Array[Int]
      block_depth : Array[Int]
    } derive(Eq, 
    Debug    )

    impl Show for HotLoopInfo

    HotLoopSummary

    source
    pub struct HotLoopSummary {
      header : Int
      blocks : Array[Int]
      latches : Array[Int]
      exits : Array[HotLoopExit]
      parent : Int
      depth : Int
    } derive(Eq, 
    Debug    )

    HotLowerOptions

    source
    pub struct HotLowerOptions {
      preserve_if_arm_single_nops : Bool
      preserve_dead_local_tee_drops : Bool
      preserve_nontrailing_nops : Bool
      preserve_trailing_nops : Bool
      preserve_typed_loop_const_prefix_spills : Bool
      preserve_flat_ir_spills : Bool
      flatten_unused_result_blocks : Bool
      preserve_struct_set_value_blocks : Bool
    }

    HotLowerOptions::new

    source
    fn HotLowerOptions::new(preserve_if_arm_single_nops? : Bool, preserve_dead_local_tee_drops? : Bool, preserve_nontrailing_nops? : Bool, preserve_trailing_nops? : Bool, preserve_typed_loop_const_prefix_spills? : Bool, preserve_flat_ir_spills? : Bool, flatten_unused_result_blocks? : Bool, preserve_struct_set_value_blocks? : Bool) -> HotLowerOptions

    HotMemArg

    source

    impl Show for HotMemArg

    HotMemArg::new

    source

    HotModuleContext

    source
    pub struct HotModuleContext {
      subtypes : Array[
    SubType    ]
      type_groups : Array[Array[
    SubType    ]]
      func_type_idxs : Array[
    TypeIdx    ]
      func_types : Array[
    FuncType    ]
      func_type_slots : Array[
    TypeIdx    ?]
      func_imports : Array[(
    Name    , 
    Name    )?]
      func_annotations : Array[Array[
    FuncAnnotation    ]]
      tables : Array[
    TableType    ]
      mems : Array[
    MemType    ]
      globals : Array[
    GlobalType    ]
      global_inits : Array[
    Expr    ?]
      global_const_inits : Array[HotConstPayload?]
      elems : Array[
    Elem    ]
      datas : Array[
    Data    ]
      tags : Array[
    TagType    ]
      imported_tag_count : Int
      uses_custom_descriptors : Bool
    } derive(Eq, 
    Debug    )

    HotNode

    source
    pub struct HotNode {
      op : HotOp
      ty : Int
      flags : UInt
      order : Int
      imm0 : Int
      imm1 : Int
      child_base : Int
      child_count : Int
    } derive(Eq, 
    Debug    )

    impl Show for HotNode

    HotNodeUseCounts

    source
    pub struct HotNodeUseCounts {
      counts : Array[Int]
    } derive(Eq, 
    Debug    )

    Lightweight exact node-use counts without use-site or local-use allocation.

    HotOp

    source
    pub enum HotOp {
      Nop
      Unreachable
      Block
      Loop
      If
      Try
      TryTable
      Br
      BrIf
      BrTable
      BrOnNull
      BrOnNonNull
      BrOnCast
      BrOnCastFail
      Return
      Call
      CallIndirect
      CallRef
      ReturnCall
      ReturnCallIndirect
      ReturnCallRef
      LocalGet
      LocalSet
      LocalTee
      GlobalGet
      GlobalSet
      Load
      Store
      MemorySize
      MemoryGrow
      MemoryCopy
      MemoryFill
      MemoryInit
      DataDrop
      TableGet
      TableSet
      TableSize
      TableGrow
      TableFill
      TableCopy
      TableInit
      ElemDrop
      Const
      Drop
      Select
      RefNull
      RefIsNull
      RefFunc
      RefGetDesc
      RefTest
      RefCast
      RefTestDesc
      RefCastDescEq
      Heap
      Continuation
      Unary
      Binary
      Compare
      Convert
      TupleMake
      TupleExtract
      StringOp
      Throw
      Rethrow
      ThrowRef
      Delegate
      Catch
      CatchAll
      Atomic
      Simd
    } derive(Eq, 
    Debug    )

    impl Show for HotOp

    HotOp::atomic_op

    source
    fn HotOp::atomic_op() -> HotOp

    HotOp::br_on_cast

    source
    fn HotOp::br_on_cast() -> HotOp

    HotOp::br_on_cast_fail

    source
    fn HotOp::br_on_cast_fail() -> HotOp

    HotOp::br_on_non_null

    source
    fn HotOp::br_on_non_null() -> HotOp

    HotOp::br_on_null

    source
    fn HotOp::br_on_null() -> HotOp

    HotOp::catch_

    source
    fn HotOp::catch_() -> HotOp

    HotOp::catch_all

    source
    fn HotOp::catch_all() -> HotOp

    HotOp::ref_get_desc

    source
    fn HotOp::ref_get_desc() -> HotOp

    HotOp::rethrow

    source
    fn HotOp::rethrow() -> HotOp

    HotPassDescriptor

    source
    pub struct HotPassDescriptor {
      name : String
      requires : Array[HotAnalysis]
      invalidates : Array[HotAnalysis]
    } derive(Eq, 
    Debug    )

    HotPassDescriptor::new

    source
    fn HotPassDescriptor::new(name : String, requires? : Array[HotAnalysis], invalidates? : Array[HotAnalysis]) -> HotPassDescriptor

    HotPostDominators

    source
    pub struct HotPostDominators {
      roots : Array[Int]
      reachable : Bitset
      postdom_sets : Array[Bitset]
      ipdoms : Array[Int]
      children : Array[Array[Int]]
      frontiers : Array[Array[Int]]
    } derive(Eq, 
    Debug    )

    HotRegionRef

    source
    pub struct HotRegionRef {
      holder : Int
    } derive(Eq, 
    Debug    )

    HotRegionRef::root

    source

    HotRewriteCtl

    source
    pub enum HotRewriteCtl[S, E] {
      Same(S)
      Replace(S, Int)
      Remove(S)
      Error(E)
    }

    HotSideTableKind

    source
    pub enum HotSideTableKind {
      ConstPayloadTable
      MemArgTable
      BranchTableTable
      CatchInfoTable
      CallSigTable
      InstrPayloadTable
    } derive(Eq, 
    Debug    )

    HotSimpleValueKey

    source
    pub enum HotSimpleValueKey {
      ConstValue(HotConstPayload)
      LocalGetValue(Int)
    } derive(Eq, 
    Debug    )

    HotSsaConcreteLocals

    source
    pub struct HotSsaConcreteLocals {
      value_locals : Array[Int]
      extra_local_types : Array[
    ValType    ]
    } derive(Eq, 
    Debug    )

    HotSsaConcreteLocals::new

    source
    fn HotSsaConcreteLocals::new(value_locals? : Array[Int], extra_local_types? : Array[
    ValType    ]) -> HotSsaConcreteLocals

    HotSsaCopy

    source
    pub struct HotSsaCopy {
      source_local : Int
      target_local : Int
    } derive(Eq, 
    Debug    )

    HotSsaCopy::new

    source
    fn HotSsaCopy::new(source_local : Int, target_local : Int) -> HotSsaCopy

    HotSsaDestroyPolicy

    source
    pub enum HotSsaDestroyPolicy {
      ReusePhiLocals
    } derive(Eq, 
    Debug    )

    HotSsaDestructionPolicy

    source
    pub enum HotSsaDestructionPolicy {
      ParallelCopiesInPredecessors
    } derive(Eq, 
    Debug    )

    HotSsaExcludedFeature

    source
    pub enum HotSsaExcludedFeature {
      ExceptionalEdges
      PersistentHotPhiNodes
      IrOwnedSsaBodies
      NonLocalValues
    } derive(Eq, 
    Debug    )

    HotSsaPendingInsert

    source
    type HotSsaPendingInsert derive(Eq, 
    Debug    )

    HotSsaPhi

    source
    pub struct HotSsaPhi {
      block : Int
      local_id : Int
    } derive(Eq, 
    Debug    )

    impl Show for HotSsaPhi

    HotSsaPhi::new

    source
    fn HotSsaPhi::new(block : Int, local_id : Int) -> HotSsaPhi

    HotSsaPhiInput

    source
    pub struct HotSsaPhiInput {
      predecessor : Int
      value_id : Int
    } derive(Eq, 
    Debug    )

    HotSsaPhiInput::new

    source
    fn HotSsaPhiInput::new(predecessor : Int, value_id : Int) -> HotSsaPhiInput

    HotSsaRegionInsertGroup

    source
    type HotSsaRegionInsertGroup derive(Eq, 
    Debug    )

    HotSsaRenamePolicy

    source
    pub enum HotSsaRenamePolicy {
      DominatorTreeRename
    } derive(Eq, 
    Debug    )

    HotSsaUseOrigin

    source
    pub enum HotSsaUseOrigin {
      LocalGetUse(Int)
      PhiInputUse(Int, Int)
    } derive(Eq, 
    Debug    )

    HotSsaValueOrigin

    source
    pub enum HotSsaValueOrigin {
      EntryParamDef(Int)
      EntryDefaultInitDef(Int)
      LocalSetDef(Int)
      LocalTeeDef(Int)
      PhiDef(Int)
    } derive(Eq, 
    Debug    )

    HotStringBuiltin

    source
    pub enum HotStringBuiltin {
      NewWtf16Array
    } derive(Eq, 
    Debug    )

    HotStringBuiltin::new_wtf16_array

    source
    fn HotStringBuiltin::new_wtf16_array() -> HotStringBuiltin

    HotTypeInfo

    source

    impl Show for HotTypeInfo

    HotUseDef

    source
    pub struct HotUseDef {
      node_uses : Array[Array[HotUseSite]]
      block_defs : Array[Bitset]
      block_uses : Array[Bitset]
      local_reads : Array[Array[Int]]
      local_writes : Array[Array[Int]]
      local_write_blocks : Array[Array[Int]]
    } derive(Eq, 
    Debug    )

    HotUseSite

    source
    pub struct HotUseSite {
      user : Int
      slot : Int
      kind : HotUseSlotKind
    } derive(Eq, 
    Debug    )

    impl Show for HotUseSite

    HotUseSlotKind

    source
    pub enum HotUseSlotKind {
      ChildUseSlot
      RootUseSlot
    } derive(Eq, 
    Debug    )

    HotVerifyError

    source
    pub enum HotVerifyError {
      InvalidBodyResultType(Int)
      MissingTypeKey(Int, String)
      MismatchedTypeKey(Int, String, Int)
      InvalidRoot(Int, Int)
      InvalidNodeType(Int, Int)
      InvalidNodeFlags(Int, UInt, UInt)
      InvalidChildSpan(Int, Int, Int)
      InvalidChildRef(Int, Int, Int)
      InvalidLabelResultType(Int, Int)
      InvalidLabelOwner(Int, Int)
      InvalidLabelOwnerKind(Int, HotLabelKind, HotOp)
      InvalidControlLabel(Int, Int)
      InvalidSideTableRef(Int, HotSideTableKind, Int)
      InvalidControlChildCount(Int, Int, Int)
      InvalidControlChild(Int, Int, Int)
      InvalidCatchPayload(Int, String)
      InvalidBranchTarget(Int, Int)
      InvalidBranchArity(Int, Int, Int, Int)
      InvalidCfgEntry(Int)
      InvalidCfgExit(Int)
      InvalidCfgBlockId(Int, Int)
      InvalidCfgEdge(Int, CfgEdge)
      InvalidCfgEdgeSymmetry(Int, CfgEdge)
      InvalidCfgNodeMapping(Int, Int)
      InvalidCfgBlockNode(Int, Int)
      InvalidCfgRegionRoot(Int, Int, Int)
      InvalidCfgShape(String, Int, Int)
      InvalidDomEntry(Int, Int)
      InvalidDomShape(String, Int, Int)
      InvalidDomReachable(Int)
      InvalidDomIdom(Int, Int)
      InvalidDomChild(Int, Int)
      InvalidDomFrontier(Int, Int)
      InvalidSsaRevision(Int, Int)
      InvalidSsaShape(String, Int, Int)
      InvalidSsaValue(Int)
      InvalidSsaPhi(Int)
      InvalidSsaLocal(Int)
      InvalidSsaNode(Int)
      InvalidSsaValueOrigin(Int, HotSsaValueOrigin)
      InvalidSsaPhiInput(Int, Int, Int)
      InvalidSsaPhiAlignment(Int, Int, Int, Int)
      InvalidSsaType(Int, 
    ValType    , 
    ValType    )
      InvalidSsaUse(Int, HotSsaUseOrigin)
      InvalidSsaDominance(Int, Int, Int)
      InvalidAnalysisOwner
      InvalidAnalysisRevision(HotAnalysis, Int, Int)
      InvalidAnalysisDependency(HotAnalysis, HotAnalysis)
    } derive(Eq, 
    Debug    )

    HotVisitCtl

    source
    pub enum HotVisitCtl[S, E] {
      Continue(S)
      Skip(S)
      Stop(S)
      Error(E)
    }

    IrTestHotFixture

    source
    pub struct IrTestHotFixture {
      mod_ : 
    Module
      code_idx : Int
      hot_func : HotFunc
    }

    EFFECT_MASK_ACQUIRE

    source
    let EFFECT_MASK_ACQUIRE : UInt

    EFFECT_MASK_ATOMIC_READ

    source
    let EFFECT_MASK_ATOMIC_READ : UInt

    EFFECT_MASK_ATOMIC_WRITE

    source
    let EFFECT_MASK_ATOMIC_WRITE : UInt

    EFFECT_MASK_CALL

    source
    let EFFECT_MASK_CALL : UInt

    EFFECT_MASK_CONTROL

    source
    let EFFECT_MASK_CONTROL : UInt

    EFFECT_MASK_GLOBAL_STATE

    source
    let EFFECT_MASK_GLOBAL_STATE : UInt

    EFFECT_MASK_LOCAL_STATE

    source
    let EFFECT_MASK_LOCAL_STATE : UInt

    EFFECT_MASK_MEMORY_READ

    source
    let EFFECT_MASK_MEMORY_READ : UInt

    EFFECT_MASK_MEMORY_WRITE

    source
    let EFFECT_MASK_MEMORY_WRITE : UInt

    EFFECT_MASK_RELEASE

    source
    let EFFECT_MASK_RELEASE : UInt

    EFFECT_MASK_SEQ_CST

    source
    let EFFECT_MASK_SEQ_CST : UInt

    EFFECT_MASK_TABLE_READ

    source
    let EFFECT_MASK_TABLE_READ : UInt

    EFFECT_MASK_TABLE_WRITE

    source
    let EFFECT_MASK_TABLE_WRITE : UInt

    EFFECT_MASK_THROW

    source
    let EFFECT_MASK_THROW : UInt

    EFFECT_MASK_TRAP

    source
    let EFFECT_MASK_TRAP : UInt

    HOT_FLAG_BRANCH

    source
    let HOT_FLAG_BRANCH : UInt

    HOT_FLAG_CALL

    source
    let HOT_FLAG_CALL : UInt

    HOT_FLAG_CONTROL

    source
    let HOT_FLAG_CONTROL : UInt

    HOT_FLAG_HAS_EXCEPTIONAL_SUCC

    source
    let HOT_FLAG_HAS_EXCEPTIONAL_SUCC : UInt

    HOT_FLAG_LOAD

    source
    let HOT_FLAG_LOAD : UInt

    HOT_FLAG_MAY_TRAP

    source
    let HOT_FLAG_MAY_TRAP : UInt

    HOT_FLAG_SIDE_EFFECT

    source
    let HOT_FLAG_SIDE_EFFECT : UInt

    HOT_FLAG_STORE

    source
    let HOT_FLAG_STORE : UInt

    HOT_FLAG_TERMINATOR

    source
    let HOT_FLAG_TERMINATOR : UInt

    HOT_FLAG_THROWS

    source
    let HOT_FLAG_THROWS : UInt

    HOT_FLAG_VALUE

    source
    let HOT_FLAG_VALUE : UInt

    HOT_IMPLICIT_FUNCTION_LABEL

    source
    let HOT_IMPLICIT_FUNCTION_LABEL : Int

    bitset_clear

    source
    fn bitset_clear(bitset : Bitset, idx : Int) -> Bool

    bitset_contains

    source
    fn bitset_contains(bitset : Bitset, idx : Int) -> Bool

    bitset_difference_into

    source
    fn bitset_difference_into(dst : Bitset, src : Bitset) -> Bool

    bitset_equals

    source
    fn bitset_equals(lhs : Bitset, rhs : Bitset) -> Bool

    bitset_for_each_set_bit

    source
    fn bitset_for_each_set_bit(bitset : Bitset, visit : (Int) -> Unit) -> Unit

    bitset_intersect_into

    source
    fn bitset_intersect_into(dst : Bitset, src : Bitset) -> Bool

    bitset_new

    source
    fn bitset_new(size : Int) -> Bitset

    bitset_set

    source
    fn bitset_set(bitset : Bitset, idx : Int) -> Bool

    bitset_union_into

    source
    fn bitset_union_into(dst : Bitset, src : Bitset) -> Bool

    block_local_defs

    source
    fn block_local_defs(use_def : HotUseDef, block_id : Int) -> Bitset

    block_local_uses

    source
    fn block_local_uses(use_def : HotUseDef, block_id : Int) -> Bitset

    cache_get_or_build_cfg

    source
    fn cache_get_or_build_cfg(cache : HotAnalysisCache, func : HotFunc) -> HotCfg

    cache_get_or_build_dom

    source
    fn cache_get_or_build_dom(cache : HotAnalysisCache, func : HotFunc) -> HotDominators

    cache_get_or_build_effects

    source
    fn cache_get_or_build_effects(cache : HotAnalysisCache, func : HotFunc) -> HotEffectsSummary

    cache_get_or_build_liveness

    source
    fn cache_get_or_build_liveness(cache : HotAnalysisCache, func : HotFunc) -> HotLiveness

    cache_get_or_build_loop_info

    source
    fn cache_get_or_build_loop_info(cache : HotAnalysisCache, func : HotFunc) -> HotLoopInfo

    cache_get_or_build_orders

    source
    fn cache_get_or_build_orders(cache : HotAnalysisCache, func : HotFunc) -> HotCfgOrders

    cache_get_or_build_postdom

    source
    fn cache_get_or_build_postdom(cache : HotAnalysisCache, func : HotFunc) -> HotPostDominators

    cache_get_or_build_ssa

    source
    fn cache_get_or_build_ssa(cache : HotAnalysisCache, func : HotFunc) -> HotLocalSsa

    cache_get_or_build_use_def

    source
    fn cache_get_or_build_use_def(cache : HotAnalysisCache, func : HotFunc) -> HotUseDef

    cache_invalidate_all

    source
    fn cache_invalidate_all(cache : HotAnalysisCache) -> Unit

    cache_invalidate_analyses

    source
    fn cache_invalidate_analyses(cache : HotAnalysisCache, analyses : Array[HotAnalysis]) -> Unit

    cfg_block_boundary_reasons

    source
    fn cfg_block_boundary_reasons(func : HotFunc, node_id : Int) -> Array[CfgBlockBoundaryReason]

    cfg_block_count

    source
    fn cfg_block_count(cfg : HotCfg) -> Int

    cfg_block_for_node

    source
    fn cfg_block_for_node(cfg : HotCfg, node_id : Int) -> Int?

    cfg_block_for_region_root

    source
    fn cfg_block_for_region_root(cfg : HotCfg, region_ref : HotRegionRef, slot : Int) -> Int?

    cfg_block_get

    source
    fn cfg_block_get(cfg : HotCfg, block_id : Int) -> HotBlockInfo

    cfg_block_worklist_seed

    source
    fn cfg_block_worklist_seed(cfg : HotCfg) -> Array[Int]

    cfg_build

    source
    fn cfg_build(func : HotFunc, conservative_exception_entries? : Bool, expand_operand_control? : Bool) -> HotCfg

    cfg_control_successor_policy

    source
    fn cfg_control_successor_policy(op : HotOp) -> CfgControlSuccessorPolicy?

    cfg_entry_block

    source
    fn cfg_entry_block(cfg : HotCfg) -> Int

    cfg_exception_target_policy

    source
    fn cfg_exception_target_policy(op : HotOp) -> CfgExceptionTargetPolicy

    cfg_exceptional_exit_block

    source
    fn cfg_exceptional_exit_block(cfg : HotCfg) -> Int?

    cfg_exit_block

    source
    fn cfg_exit_block(cfg : HotCfg) -> Int

    cfg_postorder

    source
    fn cfg_postorder(cfg : HotCfg) -> Array[Int]

    cfg_predecessor_edges

    source
    fn cfg_predecessor_edges(cfg : HotCfg, block_id : Int) -> Array[CfgEdge]

    cfg_predecessors

    source
    fn cfg_predecessors(cfg : HotCfg, block_id : Int) -> Array[CfgEdge]

    cfg_preorder

    source
    fn cfg_preorder(cfg : HotCfg) -> Array[Int]

    cfg_region_blocks_in_rpo

    source
    fn cfg_region_blocks_in_rpo(cfg : HotCfg, region_ref : HotRegionRef) -> Array[Int]

    cfg_region_root_can_reach_next

    source
    fn cfg_region_root_can_reach_next(func : HotFunc, cfg : HotCfg, region_ref : HotRegionRef, slot : Int) -> Bool

    Reports whether execution beginning at one structured-region root can reach the following root in the same region. This is stronger than inspecting the root opcode: structured controls may complete through their own labels, and exception or loop edges may still reach the continuation.

    cfg_reverse_postorder

    source
    fn cfg_reverse_postorder(cfg : HotCfg) -> Array[Int]

    cfg_reverse_postorder_from_exit

    source
    fn cfg_reverse_postorder_from_exit(cfg : HotCfg) -> Array[Int]

    cfg_reverse_postorder_from_exit_with_exceptions

    source
    fn cfg_reverse_postorder_from_exit_with_exceptions(cfg : HotCfg) -> Array[Int]

    cfg_reverse_postorder_with_exceptions

    source
    fn cfg_reverse_postorder_with_exceptions(cfg : HotCfg) -> Array[Int]

    cfg_successor_edges

    source
    fn cfg_successor_edges(cfg : HotCfg, block_id : Int) -> Array[CfgEdge]

    cfg_successors

    source
    fn cfg_successors(cfg : HotCfg, block_id : Int) -> Array[CfgEdge]

    cfg_terminator_edge_kinds

    source
    fn cfg_terminator_edge_kinds(op : HotOp) -> Array[CfgEdgeKind]

    compat_is_f32_nan

    source
    fn compat_is_f32_nan(x : Float) -> Bool

    compat_is_f64_nan

    source
    fn compat_is_f64_nan(x : Double) -> Bool

    compat_is_f64_non_finite

    source
    fn compat_is_f64_non_finite(x : Double) -> Bool

    compat_trunc_f64_to_i64_s

    source
    fn compat_trunc_f64_to_i64_s(x : Double) -> Int64?

    compat_trunc_f64_to_i64_u

    source
    fn compat_trunc_f64_to_i64_u(x : Double) -> Int64?

    dom_build

    source
    fn dom_build(cfg : HotCfg) -> HotDominators

    dom_children

    source
    fn dom_children(dom : HotDominators, block_id : Int) -> Array[Int]

    dom_debug_dump

    source
    fn dom_debug_dump(dom : HotDominators) -> String

    dom_dominates

    source
    fn dom_dominates(dom : HotDominators, lhs : Int, rhs : Int) -> Bool

    dom_frontier

    source
    fn dom_frontier(dom : HotDominators, block_id : Int) -> Array[Int]

    dom_idom

    source
    fn dom_idom(dom : HotDominators, block_id : Int) -> Int?

    dom_strictly_dominates

    source
    fn dom_strictly_dominates(dom : HotDominators, lhs : Int, rhs : Int) -> Bool

    effects_atomic_order_mask

    source
    fn effects_atomic_order_mask(order : 
    AtomicOrder    , read~ : Bool, write~ : Bool) -> UInt

    effects_atomic_orders_conflict

    source
    fn effects_atomic_orders_conflict(earlier : UInt, later : UInt, earlier_shared~ : Bool, later_shared~ : Bool) -> Bool

    effects_for_block

    source
    fn effects_for_block(func : HotFunc, cfg : HotCfg, block_id : Int) -> UInt

    effects_for_node

    source
    fn effects_for_node(func : HotFunc, node_id : Int) -> UInt

    effects_for_region

    source
    fn effects_for_region(func : HotFunc, region_ref : HotRegionRef) -> UInt

    effects_is_pure

    source
    fn effects_is_pure(mask : UInt) -> Bool

    effects_may_throw

    source
    fn effects_may_throw(mask : UInt) -> Bool

    effects_reads_memory

    source
    fn effects_reads_memory(mask : UInt) -> Bool

    effects_writes_memory

    source
    fn effects_writes_memory(mask : UInt) -> Bool

    hot_alloc_branch_table

    source
    fn hot_alloc_branch_table(func : HotFunc, table : HotBranchTable) -> Int

    hot_alloc_call_sig

    source
    fn hot_alloc_call_sig(func : HotFunc, sig : HotCallSig) -> Int

    hot_alloc_catch_info

    source
    fn hot_alloc_catch_info(func : HotFunc, info : HotCatchInfo) -> Int

    hot_alloc_child_span

    source
    fn hot_alloc_child_span(func : HotFunc, count : Int) -> Int

    hot_alloc_children

    source
    fn hot_alloc_children(func : HotFunc, count : Int) -> Int

    hot_alloc_const

    source
    fn hot_alloc_const(func : HotFunc, payload : HotConstPayload) -> Int

    hot_alloc_instr_payload

    source
    fn hot_alloc_instr_payload(func : HotFunc, payload : HotInstrPayload) -> Int

    hot_alloc_memarg

    source
    fn hot_alloc_memarg(func : HotFunc, memarg : HotMemArg) -> Int

    hot_alloc_node

    source
    fn hot_alloc_node(func : HotFunc, node : HotNode) -> Int

    hot_append_body_local

    source
    fn hot_append_body_local(func : HotFunc, ty : 
    ValType    ) -> Int

    hot_append_root

    source
    fn hot_append_root(func : HotFunc, id : Int) -> Unit

    hot_body_result_type

    source
    fn hot_body_result_type(func : HotFunc) -> Int

    hot_body_result_type_set

    source
    fn hot_body_result_type_set(func : HotFunc, ty : Int) -> Unit

    hot_branch_table_default_target

    source
    fn hot_branch_table_default_target(func : HotFunc, id : Int) -> Int

    hot_branch_table_set

    source
    fn hot_branch_table_set(func : HotFunc, node_id : Int, targets : Array[Int], default_target : Int) -> Unit

    hot_branch_table_targets

    source
    fn hot_branch_table_targets(func : HotFunc, id : Int) -> Array[Int]

    hot_branch_table_targets_for_node

    source
    fn hot_branch_table_targets_for_node(func : HotFunc, node_id : Int) -> Array[Int]

    hot_branch_target

    source
    fn hot_branch_target(func : HotFunc, node_id : Int) -> Int?

    hot_branch_target_set

    source
    fn hot_branch_target_set(func : HotFunc, node_id : Int, target : Int) -> Unit

    hot_build_atomic

    source
    fn hot_build_atomic(func : HotFunc, result_types : Array[
    ValType    ], instr : 
    Instruction    , children : Array[Int]) -> Int

    hot_build_binary

    source
    fn hot_build_binary(func : HotFunc, result_type : 
    ValType    , lhs : Int, rhs : Int) -> Int

    hot_build_block

    source
    fn hot_build_block(func : HotFunc, block_type : 
    BlockType    , body : Array[Int]) -> Int

    hot_build_br

    source
    fn hot_build_br(func : HotFunc, target : Int, values? : Array[Int]) -> Int

    hot_build_br_if

    source
    fn hot_build_br_if(func : HotFunc, target : Int, condition : Int, values? : Array[Int]) -> Int

    hot_build_br_table

    source
    fn hot_build_br_table(func : HotFunc, targets : Array[Int], default_target : Int, selector : Int, values? : Array[Int]) -> Int

    hot_build_call

    source
    fn hot_build_call(func : HotFunc, func_idx : Int, result_types : Array[
    ValType    ], args : Array[Int]) -> Int

    hot_build_call_indirect

    source
    fn hot_build_call_indirect(func : HotFunc, type_idx : 
    TypeIdx    , table_idx : 
    TableIdx    , result_types : Array[
    ValType    ], args : Array[Int], callee : Int) -> Int

    hot_build_call_ref

    source
    fn hot_build_call_ref(func : HotFunc, type_idx : 
    TypeIdx    , result_types : Array[
    ValType    ], args : Array[Int], callee_ref : Int) -> Int

    hot_build_catch_payload

    source
    fn hot_build_catch_payload(func : HotFunc, tag_idx : 
    TagIdx    , val_type : 
    ValType    ) -> Int

    Represent one legacy catch payload lane at catch-region entry. Ordered payload lanes must appear as the catch region's leading roots.

    hot_build_compare

    source
    fn hot_build_compare(func : HotFunc, lhs : Int, rhs : Int) -> Int

    hot_build_const_f32

    source
    fn hot_build_const_f32(func : HotFunc, value : 
    F32    ) -> Int

    hot_build_const_f64

    source
    fn hot_build_const_f64(func : HotFunc, value : 
    F64    ) -> Int

    hot_build_const_i32

    source
    fn hot_build_const_i32(func : HotFunc, value : 
    I32    ) -> Int

    hot_build_const_i64

    source
    fn hot_build_const_i64(func : HotFunc, value : 
    I64    ) -> Int

    hot_build_const_v128_splat

    source
    fn hot_build_const_v128_splat(func : HotFunc, byte : Byte) -> Int

    hot_build_const_v128_zero

    source
    fn hot_build_const_v128_zero(func : HotFunc) -> Int

    hot_build_convert

    source
    fn hot_build_convert(func : HotFunc, result_type : 
    ValType    , operand : Int) -> Int

    hot_build_delegate

    source
    fn hot_build_delegate(func : HotFunc, target : Int) -> Int

    hot_build_drop

    source
    fn hot_build_drop(func : HotFunc, value : Int) -> Int

    hot_build_global_get

    source
    fn hot_build_global_get(func : HotFunc, global_idx : Int, result_type : 
    ValType    ) -> Int

    hot_build_global_set

    source
    fn hot_build_global_set(func : HotFunc, global_idx : Int, value : Int) -> Int

    hot_build_heap

    source
    fn hot_build_heap(func : HotFunc, result_types : Array[
    ValType    ], instr : 
    Instruction    , children : Array[Int]) -> Int

    hot_build_if

    source
    fn hot_build_if(func : HotFunc, block_type : 
    BlockType    , condition : Int, then_body : Array[Int], else_body? : Array[Int]?) -> Int

    hot_build_load

    source
    fn hot_build_load(func : HotFunc, result_type : 
    ValType    , memarg : 
    MemArg    , address : Int) -> Int

    hot_build_local_get

    source
    fn hot_build_local_get(func : HotFunc, local_id : Int) -> Int

    hot_build_local_set

    source
    fn hot_build_local_set(func : HotFunc, local_id : Int, value : Int) -> Int

    hot_build_local_set_from_tee

    source
    fn hot_build_local_set_from_tee(func : HotFunc, tee_id : Int) -> Int

    Copy a tee's write into a statement without changing its source order. The caller must replace each moved tee use with a read at that use site.

    hot_build_local_set_from_value

    source
    fn hot_build_local_set_from_value(func : HotFunc, local_id : Int, value : Int) -> Int

    Capture an existing value at its source execution position. Use this when extracting an operand into a preceding local-set root.

    hot_build_local_tee

    source
    fn hot_build_local_tee(func : HotFunc, local_id : Int, value : Int) -> Int

    hot_build_local_tee_from_set

    source
    fn hot_build_local_tee_from_set(func : HotFunc, set_id : Int) -> Int

    Turn a set into a value-producing write without changing its source order. The caller must remove the old set and preserve this order when replacing the read that receives the tee.

    hot_build_loop

    source
    fn hot_build_loop(func : HotFunc, block_type : 
    BlockType    , body : Array[Int]) -> Int

    hot_build_node

    source
    fn hot_build_node(func : HotFunc, op : HotOp, ty : Int, imm0? : Int, imm1? : Int, children? : Array[Int]) -> Int

    hot_build_nop

    source
    fn hot_build_nop(func : HotFunc) -> Int

    hot_build_ref_func

    source
    fn hot_build_ref_func(func : HotFunc, func_idx : 
    FuncIdx    , ref_type : 
    RefType    ) -> Int

    hot_build_ref_null

    source
    fn hot_build_ref_null(func : HotFunc, value : 
    RefType    ) -> Int

    hot_build_region

    source
    fn hot_build_region(func : HotFunc, body : Array[Int], result_arity : Int) -> Int

    Build a control's region holder without introducing an encoded block. Attach the holder to a compatible control slot; result_arity is its fallthrough stack arity. Body nodes must belong to the same function.

    hot_build_resolved_block

    source
    fn hot_build_resolved_block(func : HotFunc, block_type : 
    BlockType    , params : Array[
    ValType    ], results : Array[
    ValType    ], body : Array[Int]) -> Int

    hot_build_return

    source
    fn hot_build_return(func : HotFunc, values : Array[Int]) -> Int

    hot_build_return_call

    source
    fn hot_build_return_call(func : HotFunc, func_idx : Int, args : Array[Int]) -> Int

    hot_build_return_call_indirect

    source
    fn hot_build_return_call_indirect(func : HotFunc, type_idx : 
    TypeIdx    , table_idx : 
    TableIdx    , args : Array[Int], callee : Int) -> Int

    hot_build_return_call_ref

    source
    fn hot_build_return_call_ref(func : HotFunc, type_idx : 
    TypeIdx    , args : Array[Int], callee_ref : Int) -> Int

    hot_build_select

    source
    fn hot_build_select(func : HotFunc, result_type : 
    ValType    , if_true : Int, if_false : Int, condition : Int) -> Int

    hot_build_simd

    source
    fn hot_build_simd(func : HotFunc, result_types : Array[
    ValType    ], instr : 
    Instruction    , children : Array[Int]) -> Int

    hot_build_store

    source
    fn hot_build_store(func : HotFunc, memarg : 
    MemArg    , address : Int, value : Int) -> Int

    hot_build_string_const

    source
    fn hot_build_string_const(func : HotFunc, value : Bytes) -> Int

    hot_build_table_get

    source
    fn hot_build_table_get(func : HotFunc, table_idx : Int, result_type : 
    ValType    , index : Int) -> Int

    hot_build_table_set

    source
    fn hot_build_table_set(func : HotFunc, table_idx : Int, index : Int, value : Int) -> Int

    hot_build_throw

    source
    fn hot_build_throw(func : HotFunc, tag_idx : 
    TagIdx    , args : Array[Int]) -> Int

    hot_build_throw_ref

    source
    fn hot_build_throw_ref(func : HotFunc, exnref : Int) -> Int

    hot_build_try

    source
    fn hot_build_try(func : HotFunc, block_type : 
    BlockType    , body : Array[Int], catch_body? : Array[Int]?) -> Int

    hot_build_try_table

    source
    fn hot_build_try_table(func : HotFunc, block_type : 
    BlockType    , catches : Array[HotCatchArm], body : Array[Int], catch_list_body? : Array[Int]) -> Int

    hot_build_tuple_extract

    source
    fn hot_build_tuple_extract(func : HotFunc, result_type : 
    ValType    , tuple : Int, index : Int) -> Int

    hot_build_tuple_make

    source
    fn hot_build_tuple_make(func : HotFunc, result_types : Array[
    ValType    ], values : Array[Int]) -> Int

    hot_build_unary

    source
    fn hot_build_unary(func : HotFunc, result_type : 
    ValType    , operand : Int) -> Int

    hot_build_unreachable

    source
    fn hot_build_unreachable(func : HotFunc) -> Int

    hot_call_sig_get

    source
    fn hot_call_sig_get(func : HotFunc, id : Int) -> HotCallSig

    hot_catch_info_get

    source
    fn hot_catch_info_get(func : HotFunc, id : Int) -> HotCatchInfo

    hot_catch_payload_tag

    source
    fn hot_catch_payload_tag(func : HotFunc, node_id : Int) -> 
    TagIdx

    hot_child_count

    source
    fn hot_child_count(func : HotFunc, id : Int) -> Int

    hot_child_get

    source
    fn hot_child_get(func : HotFunc, id : Int, idx : Int) -> Int

    hot_child_set

    source
    fn hot_child_set(func : HotFunc, id : Int, idx : Int, child : Int) -> Unit

    hot_child_span

    source
    fn hot_child_span(func : HotFunc, node_id : Int) -> Array[Int]

    hot_child_storage_count

    source
    fn hot_child_storage_count(func : HotFunc) -> Int

    hot_const_get

    source
    fn hot_const_get(func : HotFunc, id : Int) -> HotConstPayload

    hot_continuation_targets

    source
    fn hot_continuation_targets(func : HotFunc, node_id : Int) -> Array[Int]

    hot_continuation_targets_set

    source
    fn hot_continuation_targets_set(func : HotFunc, node_id : Int, targets : Array[Int]) -> Unit

    hot_control_demote_if_to_block

    source
    fn hot_control_demote_if_to_block(func : HotFunc, if_id : Int, new_children : Array[Int]) -> Unit

    hot_control_demote_loop_to_block

    source
    fn hot_control_demote_loop_to_block(func : HotFunc, loop_id : Int) -> Unit

    hot_control_node_label

    source
    fn hot_control_node_label(func : HotFunc, node_id : Int) -> Int

    hot_control_region_slot_info

    source
    fn hot_control_region_slot_info(op : HotOp) -> Array[HotControlRegionSlotInfo]

    hot_control_result_type_set

    source
    fn hot_control_result_type_set(func : HotFunc, control_id : Int, ty : Int) -> Unit

    hot_debug_dump_core

    source
    fn hot_debug_dump_core(func : HotFunc) -> String

    hot_default_flags_for_op

    source
    fn hot_default_flags_for_op(op : HotOp) -> UInt

    hot_delete_detached_control_forest

    source
    fn hot_delete_detached_control_forest(func : HotFunc, root_ids : Array[Int]) -> Bool

    Delete exact detached structured trees and all labels they own.

    hot_delete_detached_control_subtree

    source
    fn hot_delete_detached_control_subtree(func : HotFunc, root_id : Int) -> Bool

    Delete one exact detached structured subtree and all labels it owns.

    hot_delete_detached_forest

    source
    fn hot_delete_detached_forest(func : HotFunc, root_ids : Array[Int]) -> Bool

    Delete an exact detached forest and all labels its controls own.

    The operation fails without mutation when the roots are empty, duplicate, or overlapping; when any descendant graph is shared or cyclic; when any node is still rooted or owned by another live node; when control-label ownership is incomplete; or when any outside branch/catch targets an owned label.

    hot_delete_detached_node

    source
    fn hot_delete_detached_node(func : HotFunc, id : Int) -> Unit

    hot_delete_detached_nodes

    source
    fn hot_delete_detached_nodes(func : HotFunc, node_ids : Array[Int]) -> Unit

    Delete an exact distinct detached node set with one revision invalidation.

    hot_delete_node

    source
    fn hot_delete_node(func : HotFunc, id : Int) -> Unit

    hot_for_each_child

    source
    fn[S, E] hot_for_each_child(func : HotFunc, parent_id : Int, initial : S, visit : (S, Int, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_for_each_root

    source
    fn[S, E] hot_for_each_root(func : HotFunc, initial : S, visit : (S, Int, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_has_exceptional_succ

    source
    fn hot_has_exceptional_succ(func : HotFunc, node_id : Int) -> Bool

    hot_has_side_effect

    source
    fn hot_has_side_effect(func : HotFunc, node_id : Int) -> Bool

    hot_instr_payload_get

    source
    fn hot_instr_payload_get(func : HotFunc, id : Int) -> HotInstrPayload

    hot_is_branch

    source
    fn hot_is_branch(func : HotFunc, node_id : Int) -> Bool

    hot_is_control_node

    source
    fn hot_is_control_node(func : HotFunc, node_id : Int) -> Bool

    hot_is_terminator_node

    source
    fn hot_is_terminator_node(func : HotFunc, node_id : Int) -> Bool

    hot_label_alloc

    source
    fn hot_label_alloc(func : HotFunc, kind : HotLabelKind, result_type : Int, owner : Int, branch_arity : Int) -> Int

    hot_label_branch_arity

    source
    fn hot_label_branch_arity(func : HotFunc, label_id : Int) -> Int

    hot_label_get

    source
    fn hot_label_get(func : HotFunc, label_id : Int) -> HotLabelInfo

    hot_label_is_live

    source
    fn hot_label_is_live(func : HotFunc, label_id : Int) -> Bool

    hot_label_kind

    source
    fn hot_label_kind(func : HotFunc, label_id : Int) -> HotLabelKind

    hot_label_owner

    source
    fn hot_label_owner(func : HotFunc, label_id : Int) -> Int

    hot_label_owner_set

    source
    fn hot_label_owner_set(func : HotFunc, label_id : Int, owner : Int) -> Unit

    hot_label_result_type

    source
    fn hot_label_result_type(func : HotFunc, label_id : Int) -> Int

    hot_lift_body

    source
    fn hot_lift_body(body : 
    Expr    , locals : HotLocals, body_result_type? : 
    BlockType    ) -> HotFunc

    hot_lift_body_result

    source
    fn hot_lift_body_result(body : 
    Expr    , locals : HotLocals, body_result_type? : 
    BlockType    ) -> Result[HotFunc, HotLiftError]

    hot_lift_body_with_context

    source
    fn hot_lift_body_with_context(body : 
    Expr    , locals : HotLocals, ctx : HotModuleContext, body_result_type? : 
    BlockType    ) -> HotFunc

    hot_lift_body_with_context_result

    source
    fn hot_lift_body_with_context_result(body : 
    Expr    , locals : HotLocals, ctx : HotModuleContext, body_result_type? : 
    BlockType    ) -> Result[HotFunc, HotLiftError]

    hot_lift_body_with_context_unverified

    source
    fn hot_lift_body_with_context_unverified(body : 
    Expr    , locals : HotLocals, ctx : HotModuleContext, body_result_type? : 
    BlockType    ) -> HotFunc

    hot_lift_func

    source

    hot_lift_func_with_context

    source

    hot_lift_func_with_context_result

    source
    fn hot_lift_func_with_context_result(mod_ : 
    Module    , func_idx : 
    FuncIdx    , ctx : HotModuleContext, capture_stack_locals? : Bool, materialize_multi_values? : Bool, record_local_accesses? : Bool, record_capture_sources? : Bool) -> Result[HotFunc, HotLiftError]

    Keep original local-access provenance by default. Callers that never query hot_lift_local_accesses may omit it explicitly; capture/conflict analysis, typechecking, result materialization and the lifted graph are unchanged. The source-map getter rejects a lift made with recording disabled.

    hot_lift_func_with_context_unverified

    source
    fn hot_lift_func_with_context_unverified(mod_ : 
    Module    , func_idx : 
    FuncIdx    , ctx : HotModuleContext) -> HotFunc

    hot_lift_local_accesses

    source
    fn hot_lift_local_accesses(func : HotFunc) -> HotLiftLocalAccesses

    hot_lift_release_local_accesses

    source
    fn hot_lift_release_local_accesses(func : HotFunc) -> Unit

    Release optional source and capture provenance after its final consumer. Existing journal aliases remain valid; this drops the HotFunc owner only.

    hot_local_body_count

    source
    fn hot_local_body_count(func : HotFunc) -> Int

    hot_local_count

    source
    fn hot_local_count(func : HotFunc) -> Int

    hot_local_is_param

    source
    fn hot_local_is_param(func : HotFunc, local_id : Int) -> Bool

    hot_local_node_id_set

    source
    fn hot_local_node_id_set(func : HotFunc, node_id : Int, local_id : Int) -> Unit

    hot_local_param_count

    source
    fn hot_local_param_count(func : HotFunc) -> Int

    hot_local_type

    source
    fn hot_local_type(func : HotFunc, local_id : Int) -> 
    ValType    ?

    hot_loop_entry_values_clear

    source
    fn hot_loop_entry_values_clear(func : HotFunc, loop_id : Int) -> Array[Int]

    hot_lower_body

    source
    fn hot_lower_body(func : HotFunc) -> 
    Expr

    hot_lower_body_unverified

    source
    fn hot_lower_body_unverified(func : HotFunc) -> 
    Expr

    hot_lower_func

    source
    fn hot_lower_func(func : HotFunc) -> 
    Func

    hot_lower_func_unverified

    source
    fn hot_lower_func_unverified(func : HotFunc) -> 
    Func

    hot_lower_func_unverified_with_options

    source
    fn hot_lower_func_unverified_with_options(func : HotFunc, options : HotLowerOptions) -> 
    Func

    hot_lower_func_with_options

    source
    fn hot_lower_func_with_options(func : HotFunc, options : HotLowerOptions) -> 
    Func

    hot_make_simple_node

    source
    fn hot_make_simple_node(op : HotOp, ty : Int, canonicalized_flags : UInt, imm0 : Int, imm1 : Int, children : Array[Int]) -> HotNode

    hot_may_trap

    source
    fn hot_may_trap(func : HotFunc, node_id : Int) -> Bool

    hot_memarg_get

    source
    fn hot_memarg_get(func : HotFunc, id : Int) -> HotMemArg

    hot_module_context_from_module

    source
    fn hot_module_context_from_module(mod_ : 
    Module    ) -> HotModuleContext

    hot_module_context_validation_env

    source
    fn hot_module_context_validation_env(ctx : HotModuleContext) -> 
    Env

    Build a reusable body-validation environment from one immutable module context. Function-local labels, locals and return state are intentionally absent; the body validator adds them independently for each function.

    hot_module_func_has_annotation

    source
    fn hot_module_func_has_annotation(ctx : HotModuleContext, func_idx : 
    FuncIdx    , name : String) -> Bool

    hot_module_func_import_matches

    source
    fn hot_module_func_import_matches(ctx : HotModuleContext, func_idx : 
    FuncIdx    , module_name : String, base_name : String) -> Bool

    hot_module_resolve_array_field

    source

    hot_module_resolve_block_results

    source

    hot_module_resolve_func_import

    source

    hot_module_resolve_func_type

    source

    hot_module_resolve_func_type_idx

    source
    fn hot_module_resolve_func_type_idx(ctx : HotModuleContext, func_idx : 
    FuncIdx    ) -> 
    TypeIdx    ?

    hot_module_resolve_global_const_init

    source
    fn hot_module_resolve_global_const_init(ctx : HotModuleContext, global_idx : 
    GlobalIdx    ) -> HotConstPayload?

    hot_module_resolve_global_init

    source
    fn hot_module_resolve_global_init(ctx : HotModuleContext, global_idx : 
    GlobalIdx    ) -> 
    Expr    ?

    hot_module_resolve_global_type

    source

    hot_module_resolve_mem_index_type

    source
    fn hot_module_resolve_mem_index_type(ctx : HotModuleContext, mem_idx : 
    MemIdx    ) -> 
    ValType    ?

    hot_module_resolve_mem_type

    source

    hot_module_resolve_struct_fields

    source

    hot_module_resolve_subtype

    source

    hot_module_resolve_table_index_type

    source
    fn hot_module_resolve_table_index_type(ctx : HotModuleContext, table_idx : 
    TableIdx    ) -> 
    ValType    ?

    hot_module_resolve_table_type

    source

    hot_module_resolve_tag_type

    source

    hot_module_resolve_type_func_type

    source

    hot_module_subtype_count

    source
    fn hot_module_subtype_count(ctx : HotModuleContext) -> Int

    hot_node_count

    source
    fn hot_node_count(func : HotFunc) -> Int

    hot_node_exact_instr

    source
    fn hot_node_exact_instr(func : HotFunc, node_id : Int) -> 
    Instruction    ?

    hot_node_exact_instr_payload_id

    source
    fn hot_node_exact_instr_payload_id(func : HotFunc, node_id : Int) -> Int?

    hot_node_exact_instr_set

    source
    fn hot_node_exact_instr_set(func : HotFunc, id : Int, instr : 
    Instruction    ) -> Unit

    hot_node_flags

    source
    fn hot_node_flags(func : HotFunc, node_id : Int) -> UInt

    hot_node_get

    source
    fn hot_node_get(func : HotFunc, id : Int) -> HotNode

    hot_node_has_flag

    source
    fn hot_node_has_flag(func : HotFunc, node_id : Int, flag : UInt) -> Bool

    hot_node_is_deleted

    source
    fn hot_node_is_deleted(func : HotFunc, node_id : Int) -> Bool

    hot_node_is_live

    source
    fn hot_node_is_live(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_atomic

    source
    fn hot_node_kind_is_atomic(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_branch

    source
    fn hot_node_kind_is_branch(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_call

    source
    fn hot_node_kind_is_call(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_control

    source
    fn hot_node_kind_is_control(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_exception

    source
    fn hot_node_kind_is_exception(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_global

    source
    fn hot_node_kind_is_global(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_heap

    source
    fn hot_node_kind_is_heap(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_local

    source
    fn hot_node_kind_is_local(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_memory

    source
    fn hot_node_kind_is_memory(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_numeric

    source
    fn hot_node_kind_is_numeric(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_simd

    source
    fn hot_node_kind_is_simd(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_table

    source
    fn hot_node_kind_is_table(func : HotFunc, node_id : Int) -> Bool

    hot_node_kind_is_tuple

    source
    fn hot_node_kind_is_tuple(func : HotFunc, node_id : Int) -> Bool

    hot_node_may_throw_exception

    source
    fn hot_node_may_throw_exception(func : HotFunc, node_id : Int) -> Bool

    hot_node_op

    source
    fn hot_node_op(func : HotFunc, id : Int) -> HotOp

    hot_node_promote_to_block

    source
    fn hot_node_promote_to_block(func : HotFunc, node_id : Int, block_type : 
    BlockType    , new_children : Array[Int]) -> Unit

    hot_node_repeated_live_child

    source
    fn hot_node_repeated_live_child(func : HotFunc, node_id : Int) -> Int?

    hot_node_result_arity

    source
    fn hot_node_result_arity(func : HotFunc, node_id : Int) -> Int

    hot_node_set

    source
    fn hot_node_set(func : HotFunc, id : Int, node : HotNode) -> Unit

    hot_node_type

    source
    fn hot_node_type(func : HotFunc, node_id : Int) -> Int

    hot_node_use_count

    source
    fn hot_node_use_count(use_counts : HotNodeUseCounts, node_id : Int) -> Int

    hot_node_use_counts_build

    source
    fn hot_node_use_counts_build(func : HotFunc) -> HotNodeUseCounts

    Count every reachable live root and child reference in the current HOT snapshot.

    hot_nodes_match_simple_value

    source
    fn hot_nodes_match_simple_value(func : HotFunc, lhs : Int, rhs : Int) -> Bool

    hot_ordered_catch_payloads_repairable

    source
    fn hot_ordered_catch_payloads_repairable(func : HotFunc) -> Bool

    Report whether every typed legacy catch payload is either the exact scalar first-descendant family or one ordered same-tag lane vector under an exclusive direct block chain. Catch-all markers, loops, nested catches, sharing, outside uses, or any partial lane reject the complete function.

    hot_param_count

    source
    fn hot_param_count(func : HotFunc) -> Int

    hot_pass_invalidates

    source
    fn hot_pass_invalidates(descriptor : HotPassDescriptor) -> Array[HotAnalysis]

    hot_pass_requires

    source
    fn hot_pass_requires(descriptor : HotPassDescriptor) -> Array[HotAnalysis]

    hot_preserve_replacement_position

    source
    fn hot_preserve_replacement_position(func : HotFunc, replacement : Int, original : Int) -> Unit

    hot_region_body_ref

    source
    fn hot_region_body_ref(func : HotFunc, control_id : Int) -> HotRegionRef

    hot_region_catch_list_ref

    source
    fn hot_region_catch_list_ref(func : HotFunc, try_table_id : Int) -> HotRegionRef

    hot_region_catch_ref

    source
    fn hot_region_catch_ref(func : HotFunc, try_id : Int) -> HotRegionRef?

    hot_region_else_ref

    source
    fn hot_region_else_ref(func : HotFunc, if_id : Int) -> HotRegionRef?

    hot_region_get

    source
    fn hot_region_get(func : HotFunc, region_ref : HotRegionRef, idx : Int) -> Int

    hot_region_holder_block_label

    source
    fn hot_region_holder_block_label(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_holder_block_root

    source
    fn hot_region_holder_block_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_insert

    source
    fn hot_region_insert(func : HotFunc, region_ref : HotRegionRef, idx : Int, node_ids : Array[Int]) -> Unit

    hot_region_is_strict_no_work_block_chain

    source
    fn hot_region_is_strict_no_work_block_chain(func : HotFunc, region_ref : HotRegionRef, label_is_used : (Int) -> Bool) -> Bool

    Prove that a region is empty or contains only an unused-label resultless single-root block chain ending in an empty body or one childless nop.

    hot_region_is_strict_no_work_forest

    source
    fn hot_region_is_strict_no_work_forest(func : HotFunc, region_ref : HotRegionRef, label_is_used : (Int) -> Bool) -> Bool

    Prove that every root in a region independently forms an unused-label resultless block chain ending empty or in one childless nop.

    hot_region_remove

    source
    fn hot_region_remove(func : HotFunc, region_ref : HotRegionRef, idx : Int, count : Int) -> Array[Int]

    hot_region_repeated_live_block_body

    source
    fn hot_region_repeated_live_block_body(func : HotFunc, region_ref : HotRegionRef) -> HotRegionRef?

    hot_region_repeated_live_block_body_or_self

    source
    fn hot_region_repeated_live_block_body_or_self(func : HotFunc, region_ref : HotRegionRef) -> HotRegionRef

    hot_region_repeated_live_block_root

    source
    fn hot_region_repeated_live_block_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_repeated_live_if_root

    source
    fn hot_region_repeated_live_if_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_repeated_live_root

    source
    fn hot_region_repeated_live_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_replace_body

    source
    fn hot_region_replace_body(func : HotFunc, region_ref : HotRegionRef, node_ids : Array[Int]) -> Unit

    hot_region_result_arity

    source
    fn hot_region_result_arity(func : HotFunc, region_ref : HotRegionRef) -> Int

    hot_region_root_count

    source
    fn hot_region_root_count(func : HotFunc, region_ref : HotRegionRef) -> Int

    hot_region_set

    source
    fn hot_region_set(func : HotFunc, region_ref : HotRegionRef, idx : Int, node_id : Int) -> Int

    hot_region_single_exit_root

    source
    fn hot_region_single_exit_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_single_live_block_body

    source
    fn hot_region_single_live_block_body(func : HotFunc, region_ref : HotRegionRef) -> HotRegionRef?

    hot_region_single_live_block_body_or_self

    source
    fn hot_region_single_live_block_body_or_self(func : HotFunc, region_ref : HotRegionRef) -> HotRegionRef

    hot_region_single_live_block_root

    source
    fn hot_region_single_live_block_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_single_live_if_root

    source
    fn hot_region_single_live_if_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_single_live_root

    source
    fn hot_region_single_live_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_single_plain_br_root

    source
    fn hot_region_single_plain_br_root(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_single_plain_br_target

    source
    fn hot_region_single_plain_br_target(func : HotFunc, region_ref : HotRegionRef) -> Int?

    hot_region_splice

    source
    fn hot_region_splice(func : HotFunc, region_ref : HotRegionRef, idx : Int, remove_count : Int, node_ids : Array[Int]) -> Array[Int]

    hot_region_split_trailing_payload_roots

    source
    fn hot_region_split_trailing_payload_roots(func : HotFunc, region_ref : HotRegionRef, result_arity : Int) -> (Array[Int], Array[Int])?

    hot_region_split_trailing_plain_br_root

    source
    fn hot_region_split_trailing_plain_br_root(func : HotFunc, region_ref : HotRegionRef) -> (Array[Int], Int)?

    hot_region_split_trailing_plain_br_target

    source
    fn hot_region_split_trailing_plain_br_target(func : HotFunc, region_ref : HotRegionRef) -> (Array[Int], Int)?

    hot_region_then_ref

    source
    fn hot_region_then_ref(func : HotFunc, if_id : Int) -> HotRegionRef

    hot_region_truncate_suffix

    source
    fn hot_region_truncate_suffix(func : HotFunc, region_ref : HotRegionRef, keep_count : Int) -> Array[Int]

    hot_repair_nondefaultable_local_scopes

    source
    fn hot_repair_nondefaultable_local_scopes(func : HotFunc) -> Bool

    Preserve result types when code motion moves a local read outside the control scope that initialized its non-defaultable reference storage. Call only after a semantics-preserving transform on a valid input.

    hot_repair_ordered_catch_payloads

    source
    fn hot_repair_ordered_catch_payloads(func : HotFunc) -> Bool

    Capture exact scalar or ordered same-tag legacy catch payloads atomically. Lane locals retain source order; entry captures consume the handler stack in reverse lane order before exact old-position reads replace every payload use.

    hot_repair_scalar_catch_payloads

    source
    fn hot_repair_scalar_catch_payloads(func : HotFunc) -> Bool

    Capture every repairable scalar legacy catch payload into a typed local at catch entry and replace its exact nested first-descendant use. The complete function is preflighted before any local, node, root, child, or revision mutation; unsupported multiple payloads, nested catches, loops, sharing, or outside uses leave the function unchanged.

    hot_replace_child_span

    source
    fn hot_replace_child_span(func : HotFunc, id : Int, new_children : Array[Int]) -> Array[Int]

    hot_replace_child_spans_and_control_result_type

    source
    fn hot_replace_child_spans_and_control_result_type(func : HotFunc, control_id : Int, ty : Int, rewrites : Array[HotChildSpanRewrite]) -> Unit

    hot_replace_local_set_with_drop

    source
    fn hot_replace_local_set_with_drop(func : HotFunc, node_id : Int) -> Bool

    hot_replace_local_tee_with_value

    source
    fn hot_replace_local_tee_with_value(func : HotFunc, node_id : Int) -> Bool

    hot_replace_node

    source
    fn hot_replace_node(func : HotFunc, id : Int, new_node : HotNode, preserve_value_order? : Bool) -> Unit

    hot_replace_node_preserving_position

    source
    fn hot_replace_node_preserving_position(func : HotFunc, id : Int, new_node : HotNode) -> Unit

    hot_revision_bump

    source
    fn hot_revision_bump(func : HotFunc) -> Unit

    hot_revision_current

    source
    fn hot_revision_current(func : HotFunc) -> Int

    hot_rewrite_children_by_slot

    source
    fn[S, E] hot_rewrite_children_by_slot(func : HotFunc, parent_id : Int, initial : S, rewrite : (S, Int, Int, Int) -> HotRewriteCtl[S, E]) -> Result[S, E]

    hot_rewrite_error

    source
    fn[S, E] hot_rewrite_error(err : E) -> HotRewriteCtl[S, E]

    hot_rewrite_remove

    source
    fn[S, E] hot_rewrite_remove(state : S) -> HotRewriteCtl[S, E]

    hot_rewrite_replace

    source
    fn[S, E] hot_rewrite_replace(state : S, replacement : Int) -> HotRewriteCtl[S, E]

    hot_rewrite_same

    source
    fn[S, E] hot_rewrite_same(state : S) -> HotRewriteCtl[S, E]

    hot_root_append

    source
    fn hot_root_append(func : HotFunc, id : Int) -> Unit

    hot_root_count

    source
    fn hot_root_count(func : HotFunc) -> Int

    hot_root_get

    source
    fn hot_root_get(func : HotFunc, idx : Int) -> Int

    hot_root_insert

    source
    fn hot_root_insert(func : HotFunc, idx : Int, id : Int) -> Unit

    hot_root_remove

    source
    fn hot_root_remove(func : HotFunc, idx : Int) -> Int

    hot_root_set

    source
    fn hot_root_set(func : HotFunc, idx : Int, id : Int) -> Unit

    hot_root_span

    source
    fn hot_root_span(func : HotFunc) -> Array[Int]

    hot_root_splice

    source
    fn hot_root_splice(func : HotFunc, idx : Int, remove_count : Int, new_roots : Array[Int]) -> Array[Int]

    hot_root_storage_count

    source
    fn hot_root_storage_count(func : HotFunc) -> Int

    hot_scalar_catch_payloads_repairable

    source
    fn hot_scalar_catch_payloads_repairable(func : HotFunc) -> Bool

    Report whether every typed legacy catch payload in the function can be captured exactly once on its catch region's first-descendant line.

    hot_set_body_local_type

    source
    fn hot_set_body_local_type(func : HotFunc, local_id : Int, ty : 
    ValType    ) -> Bool

    hot_side_table_kind_for_op

    source
    fn hot_side_table_kind_for_op(op : HotOp) -> HotSideTableKind?

    hot_simple_value_key

    source
    fn hot_simple_value_key(func : HotFunc, node_id : Int) -> HotSimpleValueKey?

    hot_source_first_effect_orders

    source
    fn hot_source_first_effect_orders(func : HotFunc) -> Array[Int]

    First source-ordered external effect in each node's operand tree. Region bodies are separate scopes. The node count denotes no effect.

    hot_split_trailing_payload_roots

    source
    fn hot_split_trailing_payload_roots(func : HotFunc, roots : Array[Int], result_arity : Int) -> (Array[Int], Array[Int])?

    hot_try_table_catches_set

    source
    fn hot_try_table_catches_set(func : HotFunc, node_id : Int, catches : Array[HotCatchArm]) -> Unit

    hot_tuple_make_promote_to_block

    source
    fn hot_tuple_make_promote_to_block(func : HotFunc, tuple_make_id : Int, block_type : 
    BlockType    ) -> Unit

    hot_type_get

    source
    fn hot_type_get(func : HotFunc, type_id : Int) -> HotTypeInfo

    hot_type_intern_block_result

    source
    fn hot_type_intern_block_result(func : HotFunc, block_type : 
    BlockType    ) -> Int

    hot_type_intern_resolved_block_result

    source
    fn hot_type_intern_resolved_block_result(func : HotFunc, block_type : 
    BlockType    , params : Array[
    ValType    ], results : Array[
    ValType    ]) -> Int

    hot_type_intern_results

    source
    fn hot_type_intern_results(func : HotFunc, result_types : Array[
    ValType    ]) -> Int

    hot_type_intern_value

    source
    fn hot_type_intern_value(func : HotFunc, val_type : 
    ValType    ) -> Int

    hot_type_intern_void

    source
    fn hot_type_intern_void(_func : HotFunc) -> Int

    hot_type_is_void

    source
    fn hot_type_is_void(func : HotFunc, type_id : Int) -> Bool

    hot_type_resolve_results

    source
    fn hot_type_resolve_results(func : HotFunc, ctx : HotModuleContext, type_id : Int) -> Array[
    ValType    ]?

    hot_type_result_arity

    source
    fn hot_type_result_arity(func : HotFunc, type_id : Int) -> Int

    hot_type_results

    source
    fn hot_type_results(func : HotFunc, type_id : Int) -> Array[
    ValType    ]

    hot_type_void

    source
    fn hot_type_void(func : HotFunc) -> Int

    hot_verify_all

    source
    fn[C] hot_verify_all(func : HotFunc, cache? : C?) -> Result[Unit, HotVerifyError]

    hot_verify_all_or_abort

    source
    fn hot_verify_all_or_abort(func : HotFunc) -> Unit

    hot_verify_cached_analyses

    source
    fn hot_verify_cached_analyses(func : HotFunc, cache : HotAnalysisCache) -> Result[Unit, HotVerifyError]

    hot_verify_cfg

    source
    fn hot_verify_cfg(func : HotFunc, cfg : HotCfg) -> Result[Unit, HotVerifyError]

    hot_verify_control

    source
    fn hot_verify_control(func : HotFunc) -> Result[Unit, HotVerifyError]

    hot_verify_control_or_abort

    source
    fn hot_verify_control_or_abort(func : HotFunc) -> Unit

    hot_verify_core

    source
    fn hot_verify_core(func : HotFunc) -> Result[Unit, HotVerifyError]

    hot_verify_core_or_abort

    source
    fn hot_verify_core_or_abort(func : HotFunc) -> Unit

    hot_verify_dominators

    source
    fn hot_verify_dominators(cfg : HotCfg, dom : HotDominators) -> Result[Unit, HotVerifyError]

    hot_verify_node_exact_instr_payload

    source
    fn hot_verify_node_exact_instr_payload(func : HotFunc, node_id : Int) -> Bool

    hot_verify_ssa

    source
    fn hot_verify_ssa(func : HotFunc, cfg : HotCfg, ssa : HotLocalSsa) -> Result[Unit, HotVerifyError]

    hot_visit_continue

    source
    fn[S, E] hot_visit_continue(state : S) -> HotVisitCtl[S, E]

    hot_visit_error

    source
    fn[S, E] hot_visit_error(err : E) -> HotVisitCtl[S, E]

    hot_visit_skip

    source
    fn[S, E] hot_visit_skip(state : S) -> HotVisitCtl[S, E]

    hot_visit_stop

    source
    fn[S, E] hot_visit_stop(state : S) -> HotVisitCtl[S, E]

    hot_walk_control_regions

    source
    fn[S, E] hot_walk_control_regions(func : HotFunc, control_id : Int, initial : S, visit : (S, Int, HotControlRegionSlotInfo, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_walk_region

    source
    fn[S, E] hot_walk_region(func : HotFunc, region_id : Int, initial : S, visit : (S, Int, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_walk_subtree_postorder

    source
    fn[S, E] hot_walk_subtree_postorder(func : HotFunc, root_id : Int, initial : S, visit : (S, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_walk_subtree_preorder

    source
    fn[S, E] hot_walk_subtree_preorder(func : HotFunc, root_id : Int, initial : S, visit : (S, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    hot_weaken_body_local_to_nullable_ref

    source
    fn hot_weaken_body_local_to_nullable_ref(func : HotFunc, local_id : Int) -> Bool

    hot_worklist_walk

    source
    fn[S, E] hot_worklist_walk(func : HotFunc, seeds : Array[Int], initial : S, visit : (S, Int) -> HotVisitCtl[S, E]) -> Result[S, E]

    ir_test_assert_verify_and_lower

    source
    fn ir_test_assert_verify_and_lower(fixture : IrTestHotFixture) -> 
    Module

    ir_test_build_hot_from_wat

    source
    fn ir_test_build_hot_from_wat(text : String, code_idx? : Int) -> IrTestHotFixture

    ir_test_dump_cfg

    source
    fn ir_test_dump_cfg(func : HotFunc) -> String

    ir_test_dump_dom

    source
    fn ir_test_dump_dom(func : HotFunc) -> String

    ir_test_dump_liveness

    source
    fn ir_test_dump_liveness(func : HotFunc) -> String

    ir_test_dump_ssa

    source
    fn ir_test_dump_ssa(func : HotFunc) -> String

    live_in

    source
    fn live_in(liveness : HotLiveness, block_id : Int) -> Bitset

    live_out

    source
    fn live_out(liveness : HotLiveness, block_id : Int) -> Bitset

    liveness_build

    source
    fn liveness_build(cfg : HotCfg, use_def : HotUseDef, include_exceptional_edges? : Bool) -> HotLiveness

    liveness_build_from_func

    source
    fn liveness_build_from_func(func : HotFunc, cfg : HotCfg, include_exceptional_edges? : Bool) -> HotLiveness

    Build complete liveness without unused node-use and per-local use-site overlays. The CFG must describe the same current function snapshot; rebuild after mutation. Uses the same block scan, shape checks and fixed-point solver as liveness_build.

    local_graph_build

    source
    fn local_graph_build(func : HotFunc, cfg : HotCfg) -> HotLocalGraph

    local_graph_build_full_flow

    source
    fn local_graph_build_full_flow(func : HotFunc, cfg : HotCfg) -> HotLocalGraph

    local_graph_build_read_sources

    source
    fn local_graph_build_read_sources(func : HotFunc, cfg : HotCfg, selected_gets? : Array[Bool]?) -> HotLocalReadSources

    Include exceptional flow with the same ordered sources as the full graph. An optional arena-sized read mask limits published rows to selected gets. Unselected rows are empty/unknown; every selected row keeps full-flow sources. The mask is borrowed only during construction, never retained or mutated.

    local_graph_can_move_set_past_node

    source
    fn local_graph_can_move_set_past_node(func : HotFunc, cfg : HotCfg, graph : HotLocalGraph, set_id : Int, obstacle_id : Int) -> Array[Int]

    local_graph_entry_source_has_legal_default

    source
    fn local_graph_entry_source_has_legal_default(graph : HotLocalGraph, local_id : Int) -> Bool

    local_graph_entry_source_is_default

    source
    fn local_graph_entry_source_is_default(graph : HotLocalGraph, local_id : Int) -> Bool

    local_graph_entry_source_is_param

    source
    fn local_graph_entry_source_is_param(graph : HotLocalGraph, local_id : Int) -> Bool

    local_graph_get_is_merge

    source
    fn local_graph_get_is_merge(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_get_is_single_source

    source
    fn local_graph_get_is_single_source(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_influenced_gets_for_set

    source
    fn local_graph_influenced_gets_for_set(graph : HotLocalGraph, node_id : Int) -> Array[Int]

    local_graph_influenced_gets_for_write

    source
    fn local_graph_influenced_gets_for_write(graph : HotLocalGraph, node_id : Int) -> Array[Int]

    local_graph_local_is_already_ssa

    source
    fn local_graph_local_is_already_ssa(graph : HotLocalGraph, local_id : Int) -> Bool

    local_graph_node_is_write

    source
    fn local_graph_node_is_write(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_reaching_source_count_for_get

    source
    fn local_graph_reaching_source_count_for_get(graph : HotLocalGraph, node_id : Int) -> Int

    Read a stable LocalGraph snapshot without materializing an owned source array. Zero sources means the read has no represented reaching definition; consumers that require a complete proof must retain their unknown fallback.

    local_graph_reaching_source_for_get

    source
    fn local_graph_reaching_source_for_get(graph : HotLocalGraph, node_id : Int, source_index : Int) -> HotLocalGraphSource

    Read one source in the same order as the owned query. The source index must be below local_graph_reaching_source_count_for_get. This query does not expose or copy the graph's internal source row.

    local_graph_reaching_source_value_for_get

    source
    fn local_graph_reaching_source_value_for_get(graph : HotLocalGraph, node_id : Int, source_index : Int) -> HotLocalGraphSourceValue

    Same checked indices and order as the enum query, with a scalar return.

    local_graph_reaching_sources_for_get

    source
    fn local_graph_reaching_sources_for_get(graph : HotLocalGraph, node_id : Int) -> Array[HotLocalGraphSource]

    local_graph_source_is_default_entry

    source
    fn local_graph_source_is_default_entry(graph : HotLocalGraph, source : HotLocalGraphSource) -> Bool

    local_graph_source_is_defaultable_entry

    source
    fn local_graph_source_is_defaultable_entry(graph : HotLocalGraph, source : HotLocalGraphSource) -> Bool

    local_graph_source_is_param_entry

    source
    fn local_graph_source_is_param_entry(graph : HotLocalGraph, source : HotLocalGraphSource) -> Bool

    local_graph_write_has_merge_influences

    source
    fn local_graph_write_has_merge_influences(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_write_is_no_merge_freshenable

    source
    fn local_graph_write_is_no_merge_freshenable(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_write_is_set

    source
    fn local_graph_write_is_set(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_write_is_tee

    source
    fn local_graph_write_is_tee(graph : HotLocalGraph, node_id : Int) -> Bool

    local_graph_write_local_id

    source
    fn local_graph_write_local_id(graph : HotLocalGraph, node_id : Int) -> Int

    local_live_in

    source
    fn local_live_in(liveness : HotLiveness, block_id : Int, local_id : Int) -> Bool

    local_live_out

    source
    fn local_live_out(liveness : HotLiveness, block_id : Int, local_id : Int) -> Bool

    local_read_nodes

    source
    fn local_read_nodes(use_def : HotUseDef, local_id : Int) -> Array[Int]

    local_read_nodes_borrowed

    source
    fn local_read_nodes_borrowed(use_def : HotUseDef, local_id : Int) -> Array[Int]

    Return direct internal local-read node storage for read-only callers.

    This avoids allocating a full copy of the local-read list. Callers must not mutate the returned array.

    local_read_source_count_for_get

    source
    fn local_read_source_count_for_get(graph : HotLocalReadSources, node_id : Int) -> Int

    local_read_source_value_for_get

    source
    fn local_read_source_value_for_get(graph : HotLocalReadSources, node_id : Int, source_index : Int) -> HotLocalGraphSourceValue

    local_write_block_ids

    source
    fn local_write_block_ids(use_def : HotUseDef, local_id : Int) -> Array[Int]

    local_write_nodes

    source
    fn local_write_nodes(use_def : HotUseDef, local_id : Int) -> Array[Int]

    local_write_nodes_borrowed

    source
    fn local_write_nodes_borrowed(use_def : HotUseDef, local_id : Int) -> Array[Int]

    Return direct internal local-write node storage for read-only callers.

    This avoids allocating a full copy of the local-write list. Callers must not mutate the returned array.

    loop_blocks

    source
    fn loop_blocks(info : HotLoopInfo, loop_id : Int) -> Array[Int]

    loop_depth

    source
    fn loop_depth(info : HotLoopInfo, block_id : Int) -> Int

    loop_exits

    source
    fn loop_exits(info : HotLoopInfo, loop_id : Int) -> Array[HotLoopExit]

    loop_for_block

    source
    fn loop_for_block(info : HotLoopInfo, block_id : Int) -> Int?

    loop_header

    source
    fn loop_header(info : HotLoopInfo, loop_id : Int) -> Int

    loop_info_build

    source
    fn loop_info_build(cfg : HotCfg, dom : HotDominators) -> HotLoopInfo

    loop_info_debug_dump

    source
    fn loop_info_debug_dump(info : HotLoopInfo) -> String

    loop_latches

    source
    fn loop_latches(info : HotLoopInfo, loop_id : Int) -> Array[Int]

    node_use_count

    source
    fn node_use_count(use_def : HotUseDef, node_id : Int) -> Int

    node_use_sites

    source
    fn node_use_sites(use_def : HotUseDef, node_id : Int) -> Array[HotUseSite]

    node_use_sites_borrowed

    source
    fn node_use_sites_borrowed(use_def : HotUseDef, node_id : Int) -> Array[HotUseSite]

    Return direct internal node-use site storage for read-only callers.

    This avoids allocating a full copy of the use sites vector. Callers must not mutate the returned array.

    postdom_build

    source
    fn postdom_build(cfg : HotCfg) -> HotPostDominators

    postdom_children

    source
    fn postdom_children(postdom : HotPostDominators, block_id : Int) -> Array[Int]

    postdom_debug_dump

    source
    fn postdom_debug_dump(postdom : HotPostDominators) -> String

    postdom_frontier

    source
    fn postdom_frontier(postdom : HotPostDominators, block_id : Int) -> Array[Int]

    postdom_ipdom

    source
    fn postdom_ipdom(postdom : HotPostDominators, block_id : Int) -> Int?

    postdom_postdominates

    source
    fn postdom_postdominates(postdom : HotPostDominators, lhs : Int, rhs : Int) -> Bool

    ssa_assign_concrete_locals

    source
    fn ssa_assign_concrete_locals(func : HotFunc, ssa : HotLocalSsa, preserve_write_nodes? : 
    BitSet    ) -> HotSsaConcreteLocals

    ssa_build_local

    source
    fn ssa_build_local(func : HotFunc, cfg : HotCfg, dom : HotDominators, liveness : HotLiveness, use_def : HotUseDef) -> HotLocalSsa

    ssa_def_for_local_set

    source
    fn ssa_def_for_local_set(ssa : HotLocalSsa, node_id : Int) -> Int

    ssa_default_init_def

    source
    fn ssa_default_init_def(local_id : Int) -> HotSsaValueOrigin

    ssa_destroy_into_hot

    source
    fn ssa_destroy_into_hot(func : HotFunc, cfg : HotCfg, ssa : HotLocalSsa, policy? : HotSsaDestroyPolicy, preserve_write_nodes? : 
    BitSet    ) -> HotSsaConcreteLocals

    ssa_destruction_policy

    source
    fn ssa_destruction_policy() -> HotSsaDestructionPolicy

    ssa_insert_predecessor_copies

    source
    fn ssa_insert_predecessor_copies(func : HotFunc, region_ref : HotRegionRef, predecessor_block : HotBlockInfo, copies : Array[HotSsaCopy]) -> Array[Int]

    ssa_local_set_def

    source
    fn ssa_local_set_def(node_id : Int) -> HotSsaValueOrigin

    ssa_local_tee_def

    source
    fn ssa_local_tee_def(node_id : Int) -> HotSsaValueOrigin

    ssa_maybe_def_for_local_set

    source
    fn ssa_maybe_def_for_local_set(ssa : HotLocalSsa, node_id : Int) -> Int?

    ssa_param_entry_def

    source
    fn ssa_param_entry_def(local_id : Int) -> HotSsaValueOrigin

    ssa_phi_block

    source
    fn ssa_phi_block(ssa : HotLocalSsa, phi_id : Int) -> Int

    ssa_phi_def

    source
    fn ssa_phi_def(phi_id : Int) -> HotSsaValueOrigin

    ssa_phi_inputs

    source
    fn ssa_phi_inputs(ssa : HotLocalSsa, phi_id : Int) -> Array[HotSsaPhiInput]

    ssa_phi_local

    source
    fn ssa_phi_local(ssa : HotLocalSsa, phi_id : Int) -> Int

    ssa_phi_nodes_are_overlay_only

    source
    fn ssa_phi_nodes_are_overlay_only() -> Bool

    ssa_phi_placement_blocks

    source
    fn ssa_phi_placement_blocks(func : HotFunc, cfg : HotCfg, dom : HotDominators, liveness : HotLiveness, use_def : HotUseDef, rpo : Array[Int], local_id : Int) -> Array[Int]

    ssa_phis_for_block

    source
    fn ssa_phis_for_block(ssa : HotLocalSsa, block_id : Int) -> Array[Int]

    ssa_remove_dead_local_defs

    source
    fn ssa_remove_dead_local_defs(func : HotFunc, dead_nodes : Array[Int]) -> Unit

    ssa_rename_policy

    source
    fn ssa_rename_policy() -> HotSsaRenamePolicy

    ssa_rewrite_local_use

    source
    fn ssa_rewrite_local_use(func : HotFunc, node_id : Int, local_id : Int) -> Unit

    ssa_simple_condition_value_block_allowed

    source
    fn ssa_simple_condition_value_block_allowed(func : HotFunc, block_id : Int) -> Bool

    ssa_simple_drop_result_if_allowed

    source
    fn ssa_simple_drop_result_if_allowed(func : HotFunc, drop_id : Int, operand_slot : Int, if_id : Int) -> Bool

    ssa_simple_drop_value_block_allowed

    source
    fn ssa_simple_drop_value_block_allowed(func : HotFunc, drop_id : Int, operand_slot : Int, block_id : Int) -> Bool

    ssa_simple_result_if_arm_value_block_allowed

    source
    fn ssa_simple_result_if_arm_value_block_allowed(func : HotFunc, if_result_type : 
    ValType    , block_id : Int) -> Bool

    ssa_simple_value_block_operand_allowed

    source
    fn ssa_simple_value_block_operand_allowed(func : HotFunc, block_id : Int) -> Bool

    ssa_uses_of_value

    source
    fn ssa_uses_of_value(ssa : HotLocalSsa, value_id : Int) -> Array[HotSsaUseOrigin]

    ssa_v1_exclusions

    source
    fn ssa_v1_exclusions() -> Array[HotSsaExcludedFeature]

    ssa_value_for_local_get

    source
    fn ssa_value_for_local_get(ssa : HotLocalSsa, node_id : Int) -> Int

    ssa_value_origin

    source
    fn ssa_value_origin(ssa : HotLocalSsa, value_id : Int) -> HotSsaValueOrigin

    ssa_value_type

    source
    fn ssa_value_type(ssa : HotLocalSsa, value_id : Int) -> 
    ValType

    use_def_build

    source
    fn use_def_build(func : HotFunc, cfg? : HotCfg?) -> HotUseDef

    use_def_build_node_uses

    source
    fn use_def_build_node_uses(func : HotFunc) -> HotUseDef

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io