🥮 mooncakes.io

    vcode

    Target-independent native lowering, VCode, and code-object infrastructure

    compiler
    vcode
    register-allocation
    codegen
    Download zip
    Author
    Version
    0.14.0
    License
    Apache-2.0
    Repository
    Last updated
    13 days ago
    Downloads
    42

    #vcode

    Milky2018/vcode provides the target-independent infrastructure shared by Wasmoon's native backends. It defines the semantic vocabulary at the native compiler boundary, a streaming instruction-selection protocol, dense storage for target-owned VCode, allocation side tables and verifiers, parallel-move planning, and verified unlinked code objects.

    The module is intended for compiler backends and embedding runtimes. It is not a source-language IR, an optimizer, a register allocator, or an executable-code loader. MilkIR owns target-independent program structure and optimization; Milky2018/regalloc owns allocation policy; each target owns its instructions, ABI, frame layout, and encoding; the embedding product owns symbol resolution, executable memory, and runtime registration.

    #Packages

    PackageResponsibility
    Milky2018/vcode/native_typesCanonical native value types, signatures, calls, symbols, operation effects, traps, safepoints, source locations, and stack-map metadata.
    Milky2018/vcode/native_loweringStreaming producer-to-target protocol, target-neutral operations, transient value and block handles, and call-ABI elaboration.
    Milky2018/vcode/allocation_typesMinimal register-allocation vocabulary shared by VCode, the allocator, and their adapter: register classes, physical and virtual registers, operand roles and timing, constraints, and compact locations.
    Milky2018/vcodeDense target VCode, checked construction, allocation and frame side tables, staged verification, call-transfer planning, and parallel-move resolution.
    Milky2018/vcode/code_objectVerified machine-code bytes with typed relocations, source and trap sites, safepoints and roots, and target-neutral unwind directives.

    These packages are separate ownership seams inside one module, not successive copies of the same IR. In particular, native_lowering does not depend on the VCode package and does not retain a function graph. A target implements a TargetSink that translates each streamed operation directly into its own instruction type stored by vcode.

    #Compiler flow

    MilkIR and dialect adapters
          |
          | native_lowering.Operation, one operation at a time
          v
target TargetSink --> target-owned Inst in vcode.Function[Inst]
                                      |
                                      | verify_selected
                                      v
                      regalloc + vcode allocation side tables
                                      |
                                      | verify_allocated
                                      v
                              target frame layout
                                      |
                                      | verify_framed / verify_emission_input
                                      v
                              target machine-code emitter
                                      |
                                      v
                         code_object.UnlinkedCodeObject
                                      |
                                      v
                       embedding-owned linker and code loader

    native_types supplies the common vocabulary on both sides of the lowering seam. allocation_types supplies identities that must be shared exactly by VCode and Milky2018/regalloc; targets should not introduce parallel register class, operand-role, or allocation-location types.

    #Constructing target VCode

    The instruction payload is generic. A target defines an instruction type, then uses CheckedBuilder[Inst] to attach operands, constraints, clobbers, CFG edges, and metadata. Handles are function-owned, so values, blocks, and instructions from different functions cannot be mixed accidentally.

    ///|
    priv enum ExampleInst {
      AddOne
      Return
    } derive(Debug)

    ///|
    test "construct and verify target VCode" {
      let builder : CheckedBuilder[ExampleInst] = CheckedBuilder::new_with_results(
        "add_one",
        [I64],
        [I64],
      )
      let entry = builder.entry_block()
      let input = builder.parameter(0)
      let (_, results) = builder.append_body(
        entry,
        AddOne,
        [Input::any(input)],
        [Output::any(I64)],
        [],
        InstructionMetadata::empty(),
      )
      builder.set_terminator(
        entry,
        Return,
        [Input::any(results[0])],
        [],
        [],
        InstructionMetadata::empty(),
      )
      |> ignore

      let function = builder.finish()
      verify_selected(function)
      inspect(function.parameter_count(), content="1")
      inspect(function.instruction_count(), content="2")
      inspect(function.summary().contains("AddOne"), content="true")
    }

    CheckedBuilder is the normal production construction API: it rejects invalid operands and edges before mutation and checks local completeness when it is sealed. It does not replace verify_selected, which checks whole-function CFG and SSA properties. The lower-level Builder is useful for negative tests and tooling that deliberately needs to construct an invalid intermediate state.

    An Input or Output describes a correctness constraint independently from a placement preference. Fixed and TiedTo are hard constraints. A preferred physical register is only a hint and must not make an otherwise legal allocation fail. Early and Late operand timing lets the allocator model when an instruction stops using an input and starts defining an output.

    #Streaming native lowering

    Milky2018/vcode/native_lowering is the boundary between a legalized MilkIR producer and a native target. DirectBuilder exposes typed, transient Value and Block handles to the producer and forwards operations to a TargetSink. It retains only the bookkeeping needed to track types, map transient handles to target ids, delay one terminator, and elaborate configured call ABI details. It does not retain instructions, uses, SSA definitions, or CFG edges.

    The protocol defines operation semantics, while the producer owns source-level legalization. The target owns instruction selection, target immediates, calling-convention decisions, physical-register policy, and target VCode verification. Call-ABI elaboration may add hidden stack-map arguments or caller root scopes, but only when an embedding explicitly supplies the corresponding contract.

    Use Milky2018/milkir/native to stream core MilkIR and Milky2018/wasm_milkir/native for the WebAssembly dialect. Target users normally create an AArch64 or x64 lowering session instead of constructing a TargetSink directly.

    #Allocation and move planning

    Function[Inst] is the authoritative selected machine graph. Allocation is stored separately in Allocation, so register assignment, spills, reloads, edge transfers, safepoint roots, and frame placement do not rewrite or clone the instruction graph. Milky2018/vcode_regalloc exposes the function through the allocator's read-only view and materializes its returned plan into these side tables.

    Parallel assignments are planned with a dedicated transfer scratch for each register bank. When a cycle and a stack-to-stack transfer cannot be resolved safely with that scratch, the planner emits explicit emergency save and restore steps. The target owns the physical emergency area and must verify that its frame reserves it whenever the resolved plan requires it.

    The verification functions represent lifecycle boundaries:

    • verify_selected checks CFG shape, SSA dominance, operands, clobbers, metadata, and layout before allocation.
    • verify_allocated checks homes, operand locations, edits, interference, clobbers, and safepoint roots after allocation.
    • verify_framed adds spill-slot placement, alignment, overlap, and frame-size checks.
    • verify_emission_input is the final target-independent gate immediately before encoding.

    Verification validates the current snapshot; it does not permanently mark a mutable function or side table as verified. Run the appropriate verifier again after any later mutation.

    #Unlinked code objects

    Milky2018/vcode/code_object.build is the final reusable boundary between a target emitter and an embedding runtime. It copies the machine-code bytes and metadata, validates them, and returns an UnlinkedCodeObject only when all architecture, alignment, bounds, relocation, instruction-encoding, stack-map, root-location, and unwind-state contracts hold.

    ///|
    let object = @code_object.build(@code_object.X64, [b'\xc3'])

    Relocations remain symbolic. The package does not resolve runtime symbols, apply relocations, allocate executable memory, encode platform unwind formats, or register unwind data with the host. Those responsibilities belong to the embedding runtime. An unwind directive's offset is the code offset immediately after the prologue instruction that establishes the described state; saved register locations are relative to the canonical frame address.

    #Integration guidance

    • Import the narrowest package that owns the contract you need. A frontend usually needs native_types and native_lowering; a target also needs the root package and code_object; a loader normally needs only native_types and code_object.
    • Keep target-specific instruction variants and ABI policy in the target module. The generic packages should never depend on AArch64, x64, or Wasmoon runtime layouts.
    • Keep runtime symbol resolution and executable-code installation outside this module. Code objects are ordinary verified data until an embedding installs them.
    • Treat verification errors as compiler contract failures with structured diagnostics. Do not bypass a failed stage to continue emission.

    AllocationConstraint

    source

    A normalized register-allocation constraint.

    Operand ties are represented separately by a shared nonnegative tie label, so this type contains only location constraints.

    AllocationLocation

    source

    A packed allocation result location within one allocation session.

    Spill indices are session-local and must be translated at ownership boundaries before they are exposed as product-facing stack-slot handles.

    AllocationOperand

    source

    The canonical allocation facts for one instruction operand.

    AllocationVirtualReg

    source
    using @Milky2018/vcode/allocation_types { type VirtualReg as AllocationVirtualReg }

    A dense virtual-register identity within one allocation session.

    OperandRole

    source

    Whether an allocation operand reads, writes, or both reads and writes its virtual register.

    SSA VCode producers use Use and Def. UseDef remains available to standalone register-allocation clients that model in-place updates.

    OperandTiming

    source

    The point within an instruction where an allocation operand is read or written.

    PhysicalReg

    source

    A target physical register identified within one register class.

    RegClass

    source

    Target-neutral register-class identity shared by VCode and register allocation.

    FpVector preserves targets whose scalar floating-point and vector values occupy one physical register bank. Float and Vector remain available to standalone allocator embeddings that model distinct banks.

    SafepointKind

    source

    ValueType

    source

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

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

    AllocationVerifyError

    source
    pub suberror AllocationVerifyError {
      SelectedFailure(cause~ : VCodeVerifyError)
      SourceMismatch
      MissingValueLocation(value~ : Value)
      ForeignLocation(value~ : Value)
      LocationClassMismatch(value~ : Value)
      MissingOperandLocation(instruction~ : Instruction, operand~ : Int)
      OperandClassMismatch(instruction~ : Instruction, operand~ : Int)
      RegisterConstraintViolation(instruction~ : Instruction, operand~ : Int)
      FixedConstraintViolation(instruction~ : Instruction, operand~ : Int)
      PreservedHomeConstraintViolation(instruction~ : Instruction, operand~ : Int)
      TiedConstraintViolation(instruction~ : Instruction, operand~ : Int)
      Interference(left~ : Value, right~ : Value, location~ : Location)
      ClobberViolation(instruction~ : Instruction, value~ : Value)
      InvalidStackSlotLayout(slot~ : StackSlot)
      InvalidEdit(index~ : Int)
      MissingReload(instruction~ : Instruction, operand~ : Int)
      InvalidEdgeMove(index~ : Int)
      MissingSafepointRoot(instruction~ : Instruction, value~ : Value)
      UnexpectedSafepointRoot(instruction~ : Instruction, value~ : Value)
    } derive(Eq, 
    Debug    )

    AllocationVerifyError::equal

    source

    AllocationVerifyError::not_equal

    source

    AllocationVerifyError::output

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

    AllocationVerifyError::to_repr

    source

    AllocationVerifyError::to_string

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

    CallTransferError

    source
    pub suberror CallTransferError {
      InvalidSourceClass(index~ : Int)
      ForeignSourceStack(index~ : Int)
      InvalidSourceStackType(index~ : Int, expected~ : 
    ValueType    , actual~ : 
    ValueType    )
      InvalidSourceStackLayout(index~ : Int)
      InvalidDestinationClass(index~ : Int)
      InvalidStackOffset(index~ : Int, offset~ : Int)
      InvalidOutgoingStackRange(start~ : Int, size~ : Int)
      OutgoingStackDestinationOutOfRange(index~ : Int, offset~ : Int)
      DuplicateRegisterDestination(index~ : Int, register~ : 
    PhysicalReg    )
      OverlappingStackDestination(first~ : Int, second~ : Int)
      ProtectedLocationOverwrite(index~ : Int, location~ : Location)
      MoveResolutionFailed(cause~ : MoveResolveError)
    } derive(Eq, 
    Debug    )

    CallTransferError::equal

    source

    CallTransferError::not_equal

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

    CallTransferError::to_repr

    source

    EmissionVerifyError

    source
    pub suberror EmissionVerifyError {
      FrameFailure(cause~ : FrameVerifyError)
    } derive(Eq, 
    Debug    )

    EmissionVerifyError::equal

    source

    EmissionVerifyError::not_equal

    source

    EmissionVerifyError::output

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

    EmissionVerifyError::to_repr

    source

    EmissionVerifyError::to_string

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

    FrameVerifyError

    source
    pub suberror FrameVerifyError {
      AllocationFailure(cause~ : AllocationVerifyError)
      SourceMismatch
      InvalidFrameSize(size~ : Int)
      InvalidFrameAlignment(alignment~ : Int)
      MissingStackSlot(slot~ : StackSlot)
      MisalignedStackSlot(slot~ : StackSlot)
      OverlappingStackSlots(left~ : StackSlot, right~ : StackSlot)
      StackSlotOutOfFrame(slot~ : StackSlot)
    } derive(Eq, 
    Debug    )

    FrameVerifyError::equal

    source

    FrameVerifyError::not_equal

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

    FrameVerifyError::output

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

    FrameVerifyError::to_repr

    source

    FrameVerifyError::to_string

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

    MoveResolveError

    source

    MoveResolveError::equal

    source

    MoveResolveError::not_equal

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

    MoveResolveError::output

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

    MoveResolveError::to_repr

    source

    MoveResolveError::to_string

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

    VCodeBuildError

    source
    pub suberror VCodeBuildError {
      InvalidParameter(index~ : Int)
      InvalidBlockParameter(block~ : Block, index~ : Int)
      ForeignBlock(block~ : Block)
      ForeignValue(value~ : Value)
      InvalidOperandConstraint
      DuplicateTerminator(block~ : Block)
      BlockAlreadyTerminated(block~ : Block)
      InvalidEdgeArity(block~ : Block)
      EdgeClassMismatch(block~ : Block, index~ : Int)
      DuplicateClobber(reg~ : 
    PhysicalReg    )
      InvalidSafepointRoot(value~ : Value)
      InvalidStackMap
      MissingTerminator(block~ : Block)
      InvalidLayout
    } derive(Eq, 
    Debug    )

    VCodeBuildError::equal

    source

    VCodeBuildError::not_equal

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

    VCodeBuildError::output

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

    VCodeBuildError::to_repr

    source

    VCodeBuildError::to_string

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

    VCodeVerifyError

    source
    pub suberror VCodeVerifyError {
      EmptyFunction
      MissingTerminator(block~ : Block)
      ForeignValue(instruction~ : Instruction, value~ : Value)
      ForeignBlock(instruction~ : Instruction, block~ : Block)
      InvalidEdgeArity(instruction~ : Instruction, block~ : Block)
      EdgeClassMismatch(instruction~ : Instruction, block~ : Block, index~ : Int)
      InvalidTie(instruction~ : Instruction, operand~ : Int, tied_to~ : Int)
      FixedRegisterClassMismatch(instruction~ : Instruction, operand~ : Int)
      InvalidOperandPreference(instruction~ : Instruction, operand~ : Int)
      DuplicateClobber(instruction~ : Instruction, reg~ : 
    PhysicalReg    )
      InvalidSafepointRoot(instruction~ : Instruction, value~ : Value)
      InvalidStackMap(instruction~ : Instruction)
      UnreachableBlock(block~ : Block)
      UseBeforeDefinition(instruction~ : Instruction, value~ : Value)
      DefinitionDoesNotDominate(instruction~ : Instruction, value~ : Value)
      InvalidLayout
    } derive(Eq, 
    Debug    )

    VCodeVerifyError::equal

    source

    VCodeVerifyError::not_equal

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

    VCodeVerifyError::output

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

    VCodeVerifyError::to_repr

    source

    VCodeVerifyError::to_string

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

    Allocation

    source
    pub struct Allocation {
      // private fields
    }

    Allocation::add_edit

    source
    fn Allocation::add_edit(self : Allocation, edit : Edit) -> Bool

    Allocation::add_safepoint_root

    source
    fn Allocation::add_safepoint_root(self : Allocation, instruction : Instruction, value : Value, location : Location) -> Bool

    Allocation::allocated_operand_location_at

    source
    fn Allocation::allocated_operand_location_at(self : Allocation, instruction : Int, operand : Int) -> 
    AllocationLocation    ?

    Return a canonical allocation location by dense instruction and operand indices. Spill indices belong to this allocation.

    Allocation::allocated_value_location_at

    source

    Return a canonical allocation location by dense value index.

    Spill indices belong to this allocation and must not be used as public stack-slot handles. Compiler infrastructure that needs such a handle must call stack_slot_at on the same allocation.

    Allocation::assign_operand

    source
    fn Allocation::assign_operand(self : Allocation, instruction : Instruction, operand_index : Int, reg : 
    PhysicalReg    ) -> Bool

    Allocation::assign_operand_location

    source
    fn Allocation::assign_operand_location(self : Allocation, instruction : Instruction, operand_index : Int, location : Location) -> Bool

    Allocation::assign_value

    source
    fn Allocation::assign_value(self : Allocation, value : Value, location : Location) -> Bool

    Allocation::create_stack_slot

    source
    fn Allocation::create_stack_slot(self : Allocation, ty : 
    ValueType    , size : Int, alignment : Int) -> StackSlot

    Allocation::edge_edits_at

    source
    fn Allocation::edge_edits_at(self : Allocation, source : Block, successor_index : Int) -> ArrayView[Edit]

    Returns the allocation edits scheduled for one outgoing CFG edge.

    The returned view is read-only and remains valid while this allocation is not mutated. Target emitters should query this index instead of scanning edits() for every edge.

    Allocation::edit_count

    source
    fn Allocation::edit_count(self : Allocation) -> Int

    Allocation::edits

    source
    fn Allocation::edits(self : Allocation) -> Array[Edit]

    Allocation::edits_at

    source
    fn Allocation::edits_at(self : Allocation, instruction : Instruction, placement : PointPlacement) -> ArrayView[Edit]

    Returns the allocation edits scheduled at one instruction point.

    The returned view is read-only and remains valid while this allocation is not mutated. Target emitters should query this index instead of scanning edits() for every instruction.

    Allocation::for_function

    source
    fn[Inst] Allocation::for_function(function : Function[Inst]) -> Allocation

    Allocation::operand_location

    source
    fn Allocation::operand_location(self : Allocation, instruction : Instruction, operand_index : Int) -> Location?

    Allocation::safepoint_roots

    source
    fn Allocation::safepoint_roots(self : Allocation, instruction : Instruction) -> Array[(Value, Location)]

    Allocation::source_instruction_count

    source
    fn Allocation::source_instruction_count(self : Allocation) -> Int

    Allocation::stack_slot_alignment

    source
    fn Allocation::stack_slot_alignment(self : Allocation, slot : StackSlot) -> Int?

    Allocation::stack_slot_at

    source
    fn Allocation::stack_slot_at(self : Allocation, index : Int) -> StackSlot?

    Allocation::stack_slot_count

    source
    fn Allocation::stack_slot_count(self : Allocation) -> Int

    Allocation::stack_slot_size

    source
    fn Allocation::stack_slot_size(self : Allocation, slot : StackSlot) -> Int?

    Allocation::stack_slot_type

    source

    Allocation::statistics

    source
    fn Allocation::statistics(self : Allocation) -> AllocationStatistics

    Allocation::summary

    source
    fn Allocation::summary(self : Allocation) -> String

    Allocation::value_location

    source
    fn Allocation::value_location(self : Allocation, value : Value) -> Location?

    Return the value's default transfer home.

    A verified segmented allocation may keep the newest value in an instruction- or edge-specific location until an edit returns it here.

    AllocationBuilder

    source
    pub struct AllocationBuilder[Inst] {
      // private fields
    }

    Dense-index writer used after a verified register-allocation plan has been produced for this exact function.

    The writer avoids reconstructing and revalidating owner-tagged handles for every value, operand, and edit. Indices must come from the matching function and stay within its published counts. Final allocation invariants remain the authoritative validation boundary.

    AllocationBuilder::add_edge_transfer

    source
    fn[Inst] AllocationBuilder::add_edge_transfer(self : AllocationBuilder[Inst], source_block : Int, successor : Int, value : Int, from : 
    AllocationLocation    , to : 
    AllocationLocation    ) -> Bool

    AllocationBuilder::add_function_safepoint_roots

    source
    fn[Inst] AllocationBuilder::add_function_safepoint_roots(self : AllocationBuilder[Inst]) -> Bool

    Adds every selected VCode safepoint root through dense internal ids.

    Selected-function validation already established metadata ownership and root types; this method retains allocation-location checks without copying layouts, instruction metadata, or owner-tagged root snapshots.

    AllocationBuilder::add_safepoint_root

    source
    fn[Inst] AllocationBuilder::add_safepoint_root(self : AllocationBuilder[Inst], instruction : Int, value : Int) -> Bool

    AllocationBuilder::add_transfer

    source

    AllocationBuilder::assign_operand

    source
    fn[Inst] AllocationBuilder::assign_operand(self : AllocationBuilder[Inst], instruction : Int, operand : Int, location : 
    AllocationLocation    ) -> Bool

    AllocationBuilder::assign_value

    source
    fn[Inst] AllocationBuilder::assign_value(self : AllocationBuilder[Inst], value : Int, location : 
    AllocationLocation    ) -> Bool

    AllocationBuilder::create_stack_slot

    source
    fn[Inst] AllocationBuilder::create_stack_slot(self : AllocationBuilder[Inst], value : Int, size : Int, alignment : Int) -> Int

    AllocationBuilder::finish

    source
    fn[Inst] AllocationBuilder::finish(self : AllocationBuilder[Inst]) -> Allocation

    AllocationBuilder::from_plan_storage

    source
    fn[Inst] AllocationBuilder::from_plan_storage(function : Function[Inst], value_locations : Array[
    AllocationLocation    ?], operand_locations : Array[Array[
    AllocationLocation    ?]], spill_owners : Array[Int], spill_sizes : Array[Int], spill_alignments : Array[Int]) -> AllocationBuilder[Inst]?

    Adopts canonical location tables produced for this exact selected function.

    The caller must stop mutating the source tables after adoption. Shape, location class, spill ownership, size, and alignment are checked here so callers that disable the final allocation verifier retain the same local construction guarantees as incremental builder writes.

    AllocationBuilder::new

    source
    fn[Inst] AllocationBuilder::new(function : Function[Inst]) -> AllocationBuilder[Inst]

    AllocationBuilder::operand_value_at

    source
    fn[Inst] AllocationBuilder::operand_value_at(self : AllocationBuilder[Inst], instruction : Int, operand : Int) -> Int

    AllocationBuilder::value_location

    source

    AllocationBuilder::value_type_at

    source
    fn[Inst] AllocationBuilder::value_type_at(self : AllocationBuilder[Inst], value : Int) -> 
    ValueType

    AllocationStatistics

    source
    pub struct AllocationStatistics {
      spill_slots : Int
      spills : Int
      reloads : Int
      reg_moves : Int
      spill_to_spill : Int
    } derive(Eq, 
    Debug    )

    Read-only summary of the transfers introduced by register allocation.

    AllocationStatistics::equal

    source

    AllocationStatistics::not_equal

    source

    AllocationStatistics::to_repr

    source

    Block

    source
    pub struct Block {
      // private fields
    }

    impl Eq for Block
    impl Show for Block
    impl Debug for Block

    Block::equal

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

    Block::not_equal

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

    Block::output

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

    Block::to_repr

    source

    Block::to_string

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

    Builder

    source
    pub struct Builder[Inst] {
      // private fields
    }

    Builder::append_body

    source
    fn[Inst] Builder::append_body(self : Builder[Inst], block : Block, inst : Inst, inputs : Array[Input], outputs : Array[Output], clobbers : Array[
    PhysicalReg    ], metadata : InstructionMetadata) -> (Instruction, Array[Value]) raise VCodeBuildError

    Builder::block_parameter

    source
    fn[Inst] Builder::block_parameter(self : Builder[Inst], block : Block, index : Int) -> Value raise VCodeBuildError

    Builder::create_block

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

    Builder::entry_block

    source
    fn[Inst] Builder::entry_block(self : Builder[Inst]) -> Block

    Builder::finish

    source
    fn[Inst] Builder::finish(self : Builder[Inst]) -> Function[Inst]

    Builder::new

    source
    fn[Inst] Builder::new(name : String, parameter_types : Array[
    ValueType    ]) -> Builder[Inst]

    Builder::new_with_protocol

    source

    Builder::new_with_results

    source
    fn[Inst] Builder::new_with_results(name : String, parameter_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ]) -> Builder[Inst]

    Builder::parameter

    source
    fn[Inst] Builder::parameter(self : Builder[Inst], index : Int) -> Value raise VCodeBuildError

    Builder::set_terminator

    source
    fn[Inst] Builder::set_terminator(self : Builder[Inst], block : Block, inst : Inst, inputs : Array[Input], successors : Array[Edge], clobbers : Array[
    PhysicalReg    ], metadata : InstructionMetadata) -> Instruction raise VCodeBuildError

    CallTransfer

    source
    pub struct CallTransfer {
      // private fields
    }

    One allocated source and its physical destination in a target call layout.

    CallTransfer::to_register

    source

    CallTransfer::to_stack

    source

    CallTransferPlan

    source
    pub struct CallTransferPlan {
      stack_transfers : Array[StackArgumentTransfer]
      register_moves : Array[ParallelMove]
    } derive(Eq, 
    Debug    )

    CallTransferPlan::equal

    source

    CallTransferPlan::not_equal

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

    CallTransferPlan::to_repr

    source

    CheckedBuilder

    source
    pub struct CheckedBuilder[Inst] {
      // private fields
    }

    A production builder that establishes local VCode invariants before every mutation. The permissive Builder remains available for external tools and verifier negative tests; target selectors use this type so sealing does not need to rediscover local facts by scanning the completed instruction list.

    CheckedBuilder::append_body

    source
    fn[Inst] CheckedBuilder::append_body(self : CheckedBuilder[Inst], block : Block, inst : Inst, inputs : Array[Input], outputs : Array[Output], clobbers : Array[
    PhysicalReg    ], metadata : InstructionMetadata) -> (Instruction, Array[Value]) raise VCodeBuildError

    CheckedBuilder::block_parameter

    source
    fn[Inst] CheckedBuilder::block_parameter(self : CheckedBuilder[Inst], block : Block, index : Int) -> Value raise VCodeBuildError

    CheckedBuilder::create_block

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

    CheckedBuilder::entry_block

    source
    fn[Inst] CheckedBuilder::entry_block(self : CheckedBuilder[Inst]) -> Block

    CheckedBuilder::finish

    source
    fn[Inst] CheckedBuilder::finish(self : CheckedBuilder[Inst]) -> Function[Inst] raise VCodeBuildError

    CheckedBuilder::new

    source
    fn[Inst] CheckedBuilder::new(name : String, parameter_types : Array[
    ValueType    ]) -> CheckedBuilder[Inst]

    CheckedBuilder::new_with_protocol

    source

    CheckedBuilder::new_with_results

    source
    fn[Inst] CheckedBuilder::new_with_results(name : String, parameter_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ]) -> CheckedBuilder[Inst]

    CheckedBuilder::parameter

    source
    fn[Inst] CheckedBuilder::parameter(self : CheckedBuilder[Inst], index : Int) -> Value raise VCodeBuildError

    CheckedBuilder::set_terminator

    source
    fn[Inst] CheckedBuilder::set_terminator(self : CheckedBuilder[Inst], block : Block, inst : Inst, inputs : Array[Input], successors : Array[Edge], clobbers : Array[
    PhysicalReg    ], metadata : InstructionMetadata) -> Instruction raise VCodeBuildError

    Edge

    source
    pub struct Edge {
      target : Block
      arguments : Array[Value]
    }

    Edge::new

    source
    fn Edge::new(target : Block, arguments : Array[Value]) -> Edge

    Edit

    source
    pub struct Edit {
      point : ProgramPoint?
      kind : EditKind
    }

    Edit::edge_move

    source
    fn Edit::edge_move(source : Block, successor_index : Int, value : Value, from : Location, to : Location) -> Edit

    Edit::kind

    source
    fn Edit::kind(self : Edit) -> EditKind

    Edit::point

    source
    fn Edit::point(self : Edit) -> ProgramPoint?

    Edit::register_move

    source

    Edit::reload

    source

    Edit::spill

    source

    EditKind

    source
    pub(all) enum EditKind {
      Spill(value~ : Value, reg~ : 
    PhysicalReg    , slot~ : StackSlot)
      Reload(value~ : Value, slot~ : StackSlot, reg~ : 
    PhysicalReg    )
      Move(value~ : Value, from~ : 
    PhysicalReg    , to~ : 
    PhysicalReg    )
      EdgeMove(source~ : Block, successor_index~ : Int, value~ : Value, from~ : Location, to~ : Location)
    } derive(Eq, 
    Debug    )

    EditKind::equal

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

    EditKind::not_equal

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

    EditKind::to_repr

    source

    FrameLayout

    source
    pub struct FrameLayout {
      // private fields
    }

    FrameLayout::alignment

    source
    fn FrameLayout::alignment(self : FrameLayout) -> Int

    FrameLayout::frame_size

    source
    fn FrameLayout::frame_size(self : FrameLayout) -> Int

    FrameLayout::new

    source
    fn[Inst] FrameLayout::new(function : Function[Inst], allocation : Allocation, frame_size : Int, alignment : Int) -> FrameLayout

    FrameLayout::place_slot

    source
    fn FrameLayout::place_slot(self : FrameLayout, slot : StackSlot, offset : Int) -> Bool

    FrameLayout::slot_offset

    source
    fn FrameLayout::slot_offset(self : FrameLayout, slot : StackSlot) -> Int?

    Function

    source
    pub struct Function[Inst] {
      // private fields
    }

    Function::after

    source
    fn[Inst] Function::after(self : Function[Inst], instruction : Instruction) -> ProgramPoint?

    Function::allocation_block_instruction_at

    source
    fn[Inst] Function::allocation_block_instruction_at(self : Function[Inst], block : Int, instruction : Int) -> Int

    Function::allocation_block_instruction_count

    source
    fn[Inst] Function::allocation_block_instruction_count(self : Function[Inst], block : Int) -> Int

    Function::allocation_block_parameter_at

    source
    fn[Inst] Function::allocation_block_parameter_at(self : Function[Inst], block : Int, parameter : Int) -> 
    VirtualReg

    Function::allocation_block_parameter_count

    source
    fn[Inst] Function::allocation_block_parameter_count(self : Function[Inst], block : Int) -> Int

    Function::allocation_block_successor_at

    source
    fn[Inst] Function::allocation_block_successor_at(self : Function[Inst], block : Int, successor : Int) -> Int

    Function::allocation_block_successor_count

    source
    fn[Inst] Function::allocation_block_successor_count(self : Function[Inst], block : Int) -> Int

    Function::allocation_edge_argument_at

    source
    fn[Inst] Function::allocation_edge_argument_at(self : Function[Inst], block : Int, successor : Int, argument : Int) -> 
    VirtualReg

    Function::allocation_edge_argument_count

    source
    fn[Inst] Function::allocation_edge_argument_count(self : Function[Inst], block : Int, successor : Int) -> Int

    Function::allocation_entry_value_at

    source
    fn[Inst] Function::allocation_entry_value_at(self : Function[Inst], parameter : Int) -> 
    VirtualReg

    Returns a function parameter as a canonical allocation virtual register.

    Function::allocation_instruction_clobbers

    source
    fn[Inst] Function::allocation_instruction_clobbers(self : Function[Inst], instruction : Int) -> ArrayView[
    PhysicalReg    ]

    Function::allocation_instruction_operands

    source
    fn[Inst] Function::allocation_instruction_operands(self : Function[Inst], instruction : Int) -> ArrayView[
    AllocationOperand    ]

    Function::allocation_layout_block_id_at

    source
    fn[Inst] Function::allocation_layout_block_id_at(self : Function[Inst], block : Int) -> Int

    Returns the stable block id at a valid dense layout index.

    Function::allocation_value_type_at

    source
    fn[Inst] Function::allocation_value_type_at(self : Function[Inst], value : Int) -> 
    ValueType

    Returns the allocation type for a valid dense value id.

    Allocation consumers call these indexed accessors only after selected VCode validation, so invalid indices are programmer errors.

    Function::allocation_vreg

    source
    fn[Inst] Function::allocation_vreg(self : Function[Inst], value : Value) -> 
    VirtualReg    ?

    Function::before

    source
    fn[Inst] Function::before(self : Function[Inst], instruction : Instruction) -> ProgramPoint?

    Function::block_at

    source
    fn[Inst] Function::block_at(self : Function[Inst], index : Int) -> Block?

    Function::block_body

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

    Function::block_count

    source
    fn[Inst] Function::block_count(self : Function[Inst]) -> Int

    Function::block_index

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

    Function::block_instruction_at

    source
    fn[Inst] Function::block_instruction_at(self : Function[Inst], block : Block, index : Int) -> Instruction?

    Returns a body instruction or the block terminator by linear block index.

    Function::block_instruction_count

    source
    fn[Inst] Function::block_instruction_count(self : Function[Inst], block : Block) -> Int

    Number of instructions in a block, including its terminator when present.

    Function::block_parameter_at

    source
    fn[Inst] Function::block_parameter_at(self : Function[Inst], block : Block, index : Int) -> Value?

    Function::block_parameter_count

    source
    fn[Inst] Function::block_parameter_count(self : Function[Inst], block : Block) -> Int

    Function::block_parameters

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

    Function::block_terminator

    source
    fn[Inst] Function::block_terminator(self : Function[Inst], block : Block) -> Instruction?

    Function::entry_block

    source
    fn[Inst] Function::entry_block(self : Function[Inst]) -> Block

    Function::instruction

    source
    fn[Inst] Function::instruction(self : Function[Inst], instruction : Instruction) -> Inst?

    Function::instruction_allocation_operand_at

    source
    fn[Inst] Function::instruction_allocation_operand_at(self : Function[Inst], instruction : Instruction, index : Int) -> 
    AllocationOperand    ?

    Function::instruction_at

    source
    fn[Inst] Function::instruction_at(self : Function[Inst], index : Int) -> Instruction?

    Function::instruction_clobber_at

    source
    fn[Inst] Function::instruction_clobber_at(self : Function[Inst], instruction : Instruction, index : Int) -> 
    PhysicalReg    ?

    Function::instruction_clobber_count

    source
    fn[Inst] Function::instruction_clobber_count(self : Function[Inst], instruction : Instruction) -> Int

    Function::instruction_clobbers

    source
    fn[Inst] Function::instruction_clobbers(self : Function[Inst], instruction : Instruction) -> Array[
    PhysicalReg    ]

    Function::instruction_count

    source
    fn[Inst] Function::instruction_count(self : Function[Inst]) -> Int

    Function::instruction_index

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

    Function::instruction_is_terminator

    source
    fn[Inst] Function::instruction_is_terminator(self : Function[Inst], instruction : Instruction) -> Bool

    Function::instruction_metadata

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

    Function::instruction_operand_at

    source
    fn[Inst] Function::instruction_operand_at(self : Function[Inst], instruction : Instruction, index : Int) -> Operand?

    Function::instruction_operand_count

    source
    fn[Inst] Function::instruction_operand_count(self : Function[Inst], instruction : Instruction) -> Int

    Function::instruction_operands

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

    Function::instruction_results

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

    Function::instruction_successor_argument_at

    source
    fn[Inst] Function::instruction_successor_argument_at(self : Function[Inst], instruction : Instruction, successor : Int, argument : Int) -> Value?

    Function::instruction_successor_argument_count

    source
    fn[Inst] Function::instruction_successor_argument_count(self : Function[Inst], instruction : Instruction, successor : Int) -> Int

    Function::instruction_successor_at

    source
    fn[Inst] Function::instruction_successor_at(self : Function[Inst], instruction : Instruction, index : Int) -> Edge?

    Function::instruction_successor_count

    source
    fn[Inst] Function::instruction_successor_count(self : Function[Inst], instruction : Instruction) -> Int

    Function::instruction_successor_target

    source
    fn[Inst] Function::instruction_successor_target(self : Function[Inst], instruction : Instruction, successor : Int) -> Block?

    Function::instruction_successors

    source
    fn[Inst] Function::instruction_successors(self : Function[Inst], instruction : Instruction) -> Array[Edge]

    Function::layout

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

    Function::layout_block_at

    source
    fn[Inst] Function::layout_block_at(self : Function[Inst], index : Int) -> Block?

    Function::name

    source
    fn[Inst] Function::name(self : Function[Inst]) -> String

    Function::parameter_at

    source
    fn[Inst] Function::parameter_at(self : Function[Inst], index : Int) -> Value?

    Function::parameter_count

    source
    fn[Inst] Function::parameter_count(self : Function[Inst]) -> Int

    Function::program_point_instruction

    source
    fn[Inst] Function::program_point_instruction(self : Function[Inst], point : ProgramPoint) -> Instruction?

    Function::protocol

    source

    Function::result_types

    source

    Function::set_layout

    source
    fn[Inst] Function::set_layout(self : Function[Inst], layout : Array[Block]) -> Unit raise VCodeBuildError

    Function::summary

    source
    fn[Inst : 
    Debug    ] Function::summary(self : Function[Inst]) -> String

    Function::value_at

    source
    fn[Inst] Function::value_at(self : Function[Inst], index : Int) -> Value?

    Function::value_count

    source
    fn[Inst] Function::value_count(self : Function[Inst]) -> Int

    Function::value_index

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

    Function::value_type

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

    Input

    source

    Input::any

    source
    fn Input::any(value : Value) -> Input

    Input::any_location

    source
    fn Input::any_location(value : Value) -> Input

    Keep an input in its allocated register or spill slot. This is intended for target operations, such as ABI argument setup, whose emitter can consume a stack-resident value directly instead of requiring every input in a register at the same program point.

    Input::fixed

    source

    Input::with_preference

    source
    fn Input::with_preference(self : Input, preference : 
    PhysicalReg    ) -> Input

    Prefer a physical register without making it an allocation constraint.

    Input::with_timing

    source

    Instruction

    source
    pub struct Instruction {
      // private fields
    }

    impl Eq for Instruction
    impl Show for Instruction

    Instruction::equal

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

    Instruction::not_equal

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

    Instruction::output

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

    Instruction::to_repr

    source

    Instruction::to_string

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

    InstructionMetadata

    source

    Location

    source
    pub(all) enum Location {
      Register(
    PhysicalReg    )
      Stack(StackSlot)
    } derive(Eq)

    impl Debug for Location

    Location::equal

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

    Location::not_equal

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

    Location::to_repr

    source

    Operand

    source

    Operand::equal

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

    Operand::not_equal

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

    Operand::to_repr

    source

    OperandConstraint

    source
    pub(all) enum OperandConstraint {
      Any
      AnyLocation
      Fixed(
    PhysicalReg    )
      TiedTo(Int)
    } derive(Eq, 
    Debug    )

    OperandConstraint::equal

    source

    OperandConstraint::not_equal

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

    OperandConstraint::to_repr

    source

    Output

    source

    Output::any

    source

    Output::any_location

    source

    Materialize the result directly in its stable register or stack home. This is intended for target ABI pseudos whose emitter owns the transfer from an implicit incoming location.

    Output::fixed

    source

    Output::tied

    source
    fn Output::tied(ty : 
    ValueType    , operand_index : Int) -> Output

    Output::with_preference

    source

    Prefer a physical register without making it an allocation constraint.

    Output::with_timing

    source

    ParallelMove

    source

    ParallelMove::equal

    source

    ParallelMove::new

    source

    ParallelMove::not_equal

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

    ParallelMove::to_repr

    source

    PointPlacement

    source
    pub(all) enum PointPlacement {
      Before
      After
    } derive(Eq, 
    Debug    )

    PointPlacement::equal

    source

    PointPlacement::not_equal

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

    PointPlacement::to_repr

    source

    ProgramPoint

    source
    pub struct ProgramPoint {
      // private fields
    }

    impl Eq for ProgramPoint

    ProgramPoint::equal

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

    ProgramPoint::instruction

    source
    fn ProgramPoint::instruction(self : ProgramPoint) -> Instruction

    ProgramPoint::not_equal

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

    ProgramPoint::placement

    source
    fn ProgramPoint::placement(self : ProgramPoint) -> PointPlacement

    ProgramPoint::to_repr

    source

    RegallocLoopStatistics

    source
    pub(all) struct RegallocLoopStatistics {
      queue_pops : Int
      register_probes : Int
      occupied_segments_scanned : Int
      conflicts : Int
      evictions : Int
      bundle_splits : Int
      second_chance_attempts : Int
      max_queue_length : Int
    } derive(Eq, 
    Debug    )

    Deterministic counters for the allocator's bundle-probing loop.

    RegallocLoopStatistics::equal

    source

    RegallocLoopStatistics::not_equal

    source

    RegallocLoopStatistics::to_repr

    source

    ResolvedCallTransferPlan

    source
    pub struct ResolvedCallTransferPlan {
      stack_transfers : Array[StackArgumentTransfer]
      register_moves : ResolvedMovePlan
    } derive(Eq, 
    Debug    )

    ResolvedCallTransferPlan::equal

    source

    ResolvedCallTransferPlan::not_equal

    source

    ResolvedCallTransferPlan::to_repr

    source

    ResolvedMovePlan

    source
    pub struct ResolvedMovePlan {
      steps : Array[ResolvedMoveStep]
      requires_emergency : Bool
    } derive(Eq, 
    Debug    )

    ResolvedMovePlan::empty

    source

    ResolvedMovePlan::equal

    source

    ResolvedMovePlan::not_equal

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

    ResolvedMovePlan::to_repr

    source

    ResolvedMoveStep

    source

    ResolvedMoveStep::equal

    source

    ResolvedMoveStep::not_equal

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

    ResolvedMoveStep::to_repr

    source

    StackArgumentTransfer

    source

    StackArgumentTransfer::equal

    source

    StackArgumentTransfer::not_equal

    source

    StackArgumentTransfer::to_repr

    source

    StackSlot

    source
    pub struct StackSlot {
      // private fields
    }

    impl Eq for StackSlot
    impl Debug for StackSlot

    StackSlot::equal

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

    StackSlot::not_equal

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

    StackSlot::to_repr

    source

    SymbolReference

    source

    SymbolReference::equal

    source

    SymbolReference::not_equal

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

    SymbolReference::to_repr

    source

    TargetCompileEvent

    source
    pub(all) enum TargetCompileEvent {
      TargetAnalysisStarted
      TargetConstructionStarted
      TargetValidationStarted
      TargetCommonValidationStarted
      TargetIsaValidationStarted
      TargetSealingStarted
      TargetSelectionFinished
      RegallocStarted
      RegallocPhaseStarted(String)
      RegallocPhasesFinished
      RegallocLoopMeasured(RegallocLoopStatistics)
      RegallocFinished(AllocationStatistics)
      FramePlanningStarted
      FramePlanningFinished
      EmissionStarted
      EmissionFinished
    } derive(Eq, 
    Debug    )

    Target-compilation boundaries exposed to an embedding-owned observer.

    The observer must not mutate compiler inputs from inside the callback.

    TargetCompileEvent::equal

    source

    TargetCompileEvent::not_equal

    source

    TargetCompileEvent::to_repr

    source

    Value

    source
    pub struct Value {
      // private fields
    }

    impl Eq for Value
    impl Show for Value
    impl Debug for Value

    Value::equal

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

    Value::not_equal

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

    Value::output

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

    Value::to_repr

    source

    Value::to_string

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

    plan_call_transfers

    source
    fn plan_call_transfers(allocation : Allocation, transfers : Array[CallTransfer], outgoing_stack_start : Int, outgoing_stack_size : Int, scratch_int : Array[
    PhysicalReg    ], scratch_fp : Array[
    PhysicalReg    ], protected_locations : Array[Location]) -> CallTransferPlan raise CallTransferError

    plan_parallel_moves

    source

    plan_resolved_call_transfers

    source
    fn plan_resolved_call_transfers(allocation : Allocation, transfers : Array[CallTransfer], outgoing_stack_start : Int, outgoing_stack_size : Int, stack_scratch_int : Array[
    PhysicalReg    ], stack_scratch_fp : Array[
    PhysicalReg    ], move_scratch_int : 
    PhysicalReg    , move_scratch_fp : 
    PhysicalReg    , protected_locations : Array[Location]) -> ResolvedCallTransferPlan raise CallTransferError

    reg_class_for_value_type

    source

    resolve_parallel_moves

    source

    verify_allocated

    source
    fn[Inst] verify_allocated(function : Function[Inst], allocation : Allocation) -> Unit raise AllocationVerifyError

    verify_allocation_invariants

    source
    fn[Inst] verify_allocation_invariants(function : Function[Inst], allocation : Allocation) -> Unit raise AllocationVerifyError

    Verifies allocation-specific invariants for VCode that has already passed verify_selected. The caller must not mutate function between the two checks.

    verify_emission_input

    source
    fn[Inst] verify_emission_input(function : Function[Inst], allocation : Allocation, frame : FrameLayout) -> Unit raise EmissionVerifyError

    verify_framed

    source
    fn[Inst] verify_framed(function : Function[Inst], allocation : Allocation, frame : FrameLayout) -> Unit raise FrameVerifyError

    verify_selected

    source
    fn[Inst] verify_selected(function : Function[Inst]) -> Unit raise VCodeVerifyError

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io