🥮 mooncakes.io

    vcode

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

    compiler
    vcode
    register-allocation
    codegen
    Download zip
    Author
    Version
    0.19.0
    License
    Apache-2.0
    Repository
    Last updated
    3 days ago
    Downloads
    1K

    #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.

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

    ///|
    test "construct and verify target VCode" {
      let builder : @vcode.CheckedBuilder[ExampleInst] = @vcode.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,
        [@vcode.Input::any(input)],
        [@vcode.Output::any(I64)],
        [],
        @vcode.InstructionMetadata::empty(),
      )
      builder.set_terminator(
        entry,
        Return,
        [@vcode.Input::any(results[0])],
        [],
        [],
        @vcode.InstructionMetadata::empty(),
      )
      |> ignore

      let function = builder.finish()
      @vcode.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.

    emit_incoming_values receives function arguments and call results through the same transfer path. Each target describes its incoming pseudos, stack base, and scratch registers. Register transfers complete before stack values are loaded, including values whose allocated homes are spill slots.

    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.

    Bind embedding-owned environment fields with LoweringContext::with_environment_field_resolver. The unused fixed-binding builder with_environment_field has been removed; unresolved fields still fail target lowering.

    Plan parallel moves with plan_parallel_moves and call setup with plan_resolved_call_transfers. Both return typed move steps, including any emergency spill and reload required for stack cycles. The unused legacy resolve_parallel_moves, plan_call_transfers, and CallTransferPlan APIs have been removed. Supply concrete, reserved move scratch registers; stack transfer scratch candidates and protected root locations remain separate.

    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

    CallMaterializationError

    source
    pub(all) suberror CallMaterializationError {
      UnsupportedAbi(String)
      BuildFailure(VCodeBuildError)
    }

    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

    FrameStorageError

    source
    pub(all) suberror FrameStorageError {
      InvalidSavedRegister(reg~ : 
    PhysicalReg    , offset~ : Int)
      InvalidStackSlot(slot~ : StackSlot)
      ResultAreaMismatch(expected~ : Int, actual~ : Int)
      InvalidStackObjectArea(message~ : String)
      InvalidEmergencyMoveArea(offset~ : Int?)
      SavedRegisterSetMismatch
    }

    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

    InternalAbiError

    source
    pub suberror InternalAbiError {
      InvalidRegister(role~ : String, index~ : Int)
      DuplicateRegister(role~ : String, index~ : Int)
      ContextRegisterReused(index~ : Int)
      ResultAreaRegisterReused(index~ : Int)
      InvalidSignature(message~ : String)
    } derive(Eq, 
    Debug    )

    InternalAbiError::equal

    source

    InternalAbiError::not_equal

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

    InternalAbiError::output

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

    InternalAbiError::to_repr

    source

    InternalAbiError::to_string

    source
    fn InternalAbiError::to_string(self : InternalAbiError) -> 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

    TargetVCodeVerifyError

    source
    pub(all) suberror TargetVCodeVerifyError {
      CommonFailure(cause~ : VCodeVerifyError)
      InvalidInstruction(instruction~ : Instruction, message~ : String)
    } derive(Eq, 
    Debug    )

    TargetVCodeVerifyError::equal

    source

    TargetVCodeVerifyError::not_equal

    source

    TargetVCodeVerifyError::output

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

    TargetVCodeVerifyError::to_repr

    source

    TargetVCodeVerifyError::to_string

    source
    fn TargetVCodeVerifyError::to_string(self : TargetVCodeVerifyError) -> 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

    AbiMaterialization

    source
    pub(all) enum AbiMaterialization {
      Ordinary
      PlatformResults(
    Signature    )
      InternalResults(
    Signature    , InternalCallPlan)
      ForwardResultArea(Int, indirect~ : Bool)
      ReceiveResultArea
      ReceiveRegisterResult(
    ValueType    , 
    PhysicalReg    )
      ReceiveAreaResult(
    ValueType    , Int)
      ReturnRegisterResult(
    ValueType    )
      ReturnAreaResult(
    ValueType    )
      Return
    }

    ABI roles used after checking every instruction's local operand shape.

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

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

    Completes selected-function output without relying on the optional dataflow verifier. Every home and implicit operand must have been assigned.

    AllocationBuilder::for_selected_function

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

    Creates final output tables for selected operands, including implicit GC roots that are visible to allocation but not ordinary instruction operands.

    AllocationBuilder::new

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

    AllocationBuilder::value_location

    source

    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

    CallArgumentLocation

    source
    pub(all) enum CallArgumentLocation {
      CallRegister(
    PhysicalReg    )
      CallStack(Int)
    } derive(Eq, 
    Debug    )

    CallArgumentLocation::equal

    source

    CallArgumentLocation::not_equal

    source

    CallArgumentLocation::to_repr

    source

    CallLayout

    source
    pub struct CallLayout {
      arguments : ArrayView[CallArgumentLocation]
      stack_size : Int
    } derive(Eq, 
    Debug    )

    CallLayout::equal

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

    CallLayout::not_equal

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

    CallLayout::to_repr

    source

    CallResultLocation

    source

    CallResultLocation::equal

    source

    CallResultLocation::not_equal

    source

    CallResultLocation::to_repr

    source

    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

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

    source
    fn[Inst] CheckedBuilder::append_body_unconstrained(self : CheckedBuilder[Inst], block : Block, inst : Inst, inputs : Array[Value], output_types : Array[
    ValueType    ], clobbers : Array[
    PhysicalReg    ], metadata : InstructionMetadata) -> (Instruction, Array[Value]) raise VCodeBuildError

    Append the common target-selected instruction shape without materializing temporary Input and Output records. Values remain ownership-checked and all CheckedBuilder local invariants are enforced before mutation.

    CheckedBuilder::append_float_to_int_checks

    source

    Preserve NaN and range trap order before a trapping conversion. Targets supply the concrete trap pseudos, which have no implicit clobbers.

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

    source
    fn[Inst] CheckedBuilder::materialize_abi_words(self : CheckedBuilder[Inst], block : Block, operands : Array[Value], types : Array[
    ValueType    ], make_move : (
    ValueType    ) -> Inst, operand_start? : Int) -> Array[Value] raise VCodeBuildError

    Restore ABI types for erased raw-word bitcasts. Register allocation may coalesce the copy, while spilled arguments retain correctly typed homes.

    CheckedBuilder::materialize_atomic_address

    source
    fn[Inst] CheckedBuilder::materialize_atomic_address(self : CheckedBuilder[Inst], block : Block, operation : 
    Operation    , operands : Array[Value], load_offset : (UInt64) -> Inst, add_address : Inst) -> Array[Value] raise VCodeBuildError

    Atomic pseudos address memory at offset zero. Materialize a nonzero static offset before the selected atomic instruction and leave trap metadata there.

    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

    CheckedBuilder::value_type

    source

    Inspect an owned value without exposing mutable builder storage.

    CodeSites

    source
    pub struct CodeSites {
      // private fields
    }

    ConditionalEdgeLayout

    source
    pub struct ConditionalEdgeLayout {
      first_target : Block
      first_moves : ResolvedMovePlan
      second_target : Block
      second_moves : ResolvedMovePlan
      first_when_true : Bool
      direct_branch : Bool
      second_falls_through : Bool
    }

    DirectLoweringState

    source
    pub struct DirectLoweringState[Inst, Failure] {
      builder : CheckedBuilder[Inst]
      context : LoweringContext
      protocol : 
    CallProtocol
      signature : 
    Signature
      result_area : Value?
      on_event : (TargetCompileEvent) -> Unit
      // private fields
    }

    State owned by one streaming VCode construction, shared by native targets.

    DirectLoweringState::alias_word_bitcast

    source

    Return a new semantic value ID backed by the same untraced machine word.

    DirectLoweringState::block

    source
    fn[Inst, Failure] DirectLoweringState::block(self : DirectLoweringState[Inst, Failure], id : Int) -> Block

    DirectLoweringState::constructed_function

    source
    fn[Inst, Failure] DirectLoweringState::constructed_function(self : DirectLoweringState[Inst, Failure]) -> Function[Inst]?

    DirectLoweringState::create_block

    source
    fn[Inst, Failure] DirectLoweringState::create_block(self : DirectLoweringState[Inst, Failure], parameter_types : Array[
    ValueType    ]) -> (Int, Array[Int])

    DirectLoweringState::create_stack_object

    source
    fn[Inst, Failure] DirectLoweringState::create_stack_object(self : DirectLoweringState[Inst, Failure], size : Int, alignment : Int) -> Int

    DirectLoweringState::edge

    source
    fn[Inst, Failure] DirectLoweringState::edge(self : DirectLoweringState[Inst, Failure], block : Block, target : Int, ids : Array[Int], make_move : (
    ValueType    ) -> Inst) -> Edge raise VCodeBuildError

    Materialize typed definitions only when a raw word alias crosses a block edge.

    DirectLoweringState::emit_tail_call

    source

    Materialize and validate a tail call with the target's instruction and clobbers.

    DirectLoweringState::finish_construction

    source
    fn[Inst, Failure] DirectLoweringState::finish_construction(self : DirectLoweringState[Inst, Failure], build_failure : (VCodeBuildError) -> Failure) -> Unit

    DirectLoweringState::first_error

    source
    fn[Inst, Failure] DirectLoweringState::first_error(self : DirectLoweringState[Inst, Failure]) -> Failure?

    DirectLoweringState::instruction_index

    source
    fn[Inst, Failure] DirectLoweringState::instruction_index(self : DirectLoweringState[Inst, Failure]) -> Int

    DirectLoweringState::instruction_operands

    source
    fn[Inst, Failure] DirectLoweringState::instruction_operands(self : DirectLoweringState[Inst, Failure], operand_ids : Array[Int], root_ids : Array[Int]) -> (Array[Value], Array[
    ValueType    ], Array[Value])

    These buffers are consumed synchronously by selection.

    DirectLoweringState::materialize_return_values

    source

    Place the values of a function's return using its ABI.

    DirectLoweringState::new

    source
    fn[Inst, Failure] DirectLoweringState::new(builder : CheckedBuilder[Inst], context : LoweringContext, protocol : 
    CallProtocol    , signature : 
    Signature    , values : Array[Value], result_area : Value?, on_event : (TargetCompileEvent) -> Unit) -> DirectLoweringState[Inst, Failure]

    DirectLoweringState::record_error

    source
    fn[Inst, Failure] DirectLoweringState::record_error(self : DirectLoweringState[Inst, Failure], error : Failure) -> Unit

    DirectLoweringState::record_results

    source
    fn[Inst, Failure] DirectLoweringState::record_results(self : DirectLoweringState[Inst, Failure], results : Array[Value], result_types : Array[
    ValueType    ]) -> Array[Int]

    DirectLoweringState::stack_object

    source
    fn[Inst, Failure] DirectLoweringState::stack_object(self : DirectLoweringState[Inst, Failure], id : Int) -> (Int, Int)

    DirectLoweringState::switch_targets

    source
    fn[Inst, Failure] DirectLoweringState::switch_targets(self : DirectLoweringState[Inst, Failure], block : Block, cases : Array[
    TargetSwitchCase    ], default_target : Int, default_arguments : Array[Int], make_move : (
    ValueType    ) -> Inst) -> (Array[UInt64], Array[Edge]) raise VCodeBuildError

    DirectLoweringState::switch_to_block

    source
    fn[Inst, Failure] DirectLoweringState::switch_to_block(self : DirectLoweringState[Inst, Failure], block_id : Int) -> Unit

    DirectLoweringState::tail_call_inputs

    source

    Prepare internal tail-call arguments, including the caller's result area.

    DirectLoweringState::target_value

    source
    fn[Inst, Failure] DirectLoweringState::target_value(self : DirectLoweringState[Inst, Failure], id : Int) -> Value

    DirectLoweringState::target_values

    source
    fn[Inst, Failure] DirectLoweringState::target_values(self : DirectLoweringState[Inst, Failure], ids : Array[Int]) -> Array[Value]

    DirectLoweringState::terminator_metadata

    source
    fn[Inst, Failure] DirectLoweringState::terminator_metadata(self : DirectLoweringState[Inst, Failure], source : 
    SourceLocation    ?, live_gc_roots : Array[Int]) -> InstructionMetadata

    Attach the recorded live roots when sealing a block.

    DirectLoweringState::value_type

    source
    fn[Inst, Failure] DirectLoweringState::value_type(self : DirectLoweringState[Inst, Failure], id : Int) -> 
    ValueType

    DirectOperationSource

    source
    pub struct DirectOperationSource {
      // private fields
    }

    Source and liveness information for one operation, including any checks emitted before its selected instruction.

    DirectOperationSource::metadata

    source

    DirectOperationSource::new

    source

    DirectOperationSource::selected_metadata

    source

    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

    FloatTrapCondition

    source
    pub(all) enum FloatTrapCondition {
      Unordered
      LessThan
      LessOrEqual
      GreaterOrEqual
    } derive(Eq, 
    Debug    )

    FloatTrapCondition::equal

    source

    FloatTrapCondition::not_equal

    source

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

    FrameRequirements

    source
    pub(all) struct FrameRequirements {
      outgoing_args_size : Int
      incoming_args_size : Int
      tail_args_size : Int
      result_area_size : Int
      has_calls : Bool
      stack_objects : StackObjectRequirements?
    }

    FrameStorage

    source
    pub struct FrameStorage {
      // private fields
    }

    The local frame areas shared by targets. Incoming arguments, tail-call staging and frame records are planned by the target ABI.

    FrameStorage::emergency_move_offset

    source
    fn FrameStorage::emergency_move_offset(self : FrameStorage) -> Int?

    FrameStorage::local_size

    source
    fn FrameStorage::local_size(self : FrameStorage) -> Int

    FrameStorage::place_slots

    source
    fn FrameStorage::place_slots(self : FrameStorage, layout : FrameLayout) -> Unit

    FrameStorage::plan

    source
    fn FrameStorage::plan(requirements : FrameRequirements, allocation : Allocation, requires_emergency_moves : Bool, saved : Array[
    PhysicalReg    ]) -> FrameStorage

    FrameStorage::result_area_offset

    source
    fn FrameStorage::result_area_offset(self : FrameStorage) -> Int?

    FrameStorage::saved_registers

    source

    FrameStorage::stack_object_offset

    source
    fn FrameStorage::stack_object_offset(self : FrameStorage, id : Int) -> Int?

    FrameStorage::summary

    source
    fn FrameStorage::summary(self : FrameStorage, outgoing_args_size : Int) -> String

    FrameStorage::verify

    source
    fn FrameStorage::verify(self : FrameStorage, layout : FrameLayout, allocation : Allocation, requirements : FrameRequirements, expected_saved : Array[
    PhysicalReg    ]) -> Unit raise FrameStorageError

    FrameUse

    source
    pub(all) enum FrameUse {
      Call(Int, Int)
      Incoming(Int)
      Tail(Int)
      LocalObject(Int, Int, Int)
    }

    The ABI quantities contributed by one selected instruction.

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

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

    Keep the register-allocation order intact. Emission alone places returning helper diamonds after the normal blocks, preserving every original edge.

    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_annotations

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

    Return a read-only annotation view, or None for an unowned instruction.

    Function::instruction_at

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

    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

    InstructionAnnotations

    source
    pub struct InstructionAnnotations {
      // private fields
    }

    A read-only view of source, trap and safepoint annotations. The view retains its metadata without exposing mutable GC-root storage.

    InstructionAnnotations::safepoint

    source

    InstructionAnnotations::source

    source

    InstructionAnnotations::stack_map

    source

    InstructionAnnotations::trap

    source

    InstructionMetadata

    source

    IntegerCondition

    source
    pub(all) enum IntegerCondition {
      Eq
      Ne
      Lt
      Le
      Gt
      Ge
      Lo
      Ls
      Hi
      Hs
    } derive(Eq, 
    Debug    )

    IntegerCondition::equal

    source

    IntegerCondition::not_equal

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

    IntegerCondition::to_repr

    source

    InternalAbi

    source
    pub struct InternalAbi {
      result_area_argument : 
    PhysicalReg
      // private fields
    }

    Register assignment shared by the native backends' internal calls.

    InternalAbi::call_layout

    source

    InternalAbi::call_plan

    source

    InternalAbi::new

    source
    fn InternalAbi::new(context_argument : Int, result_area_argument : Int, integer_arguments : Array[Int], fp_arguments : Array[Int], integer_results : Array[Int], fp_results : Array[Int]) -> InternalAbi raise InternalAbiError

    InternalAbi::result_layout

    source

    InternalCallPlan

    source
    pub struct InternalCallPlan {
      arguments : ArrayView[CallArgumentLocation]
      results : ArrayView[CallResultLocation]
      stack_size : Int
      result_area_size : Int
    } derive(Eq, 
    Debug    )

    InternalCallPlan::equal

    source

    InternalCallPlan::not_equal

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

    InternalCallPlan::result_area_register

    source

    InternalCallPlan::to_repr

    source

    InternalCallPlan::valid_results

    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

    LoweringContext

    source
    pub struct LoweringContext {
      internal_abi : InternalAbi
      // private fields
    }

    LoweringContext::environment_field_offsets

    source

    LoweringContext::new

    source
    fn LoweringContext::new(internal_abi : InternalAbi) -> LoweringContext

    LoweringContext::with_environment_field_resolver

    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

    RegisterWidth

    source
    pub(all) enum RegisterWidth {
      W32
      W64
    } derive(Eq, 
    Debug    )

    RegisterWidth::equal

    source

    RegisterWidth::not_equal

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

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

    ScalarIntUnary

    source
    pub(all) enum ScalarIntUnary {
      Mvn
      Clz
      Rbit
      Neg
    } derive(Eq, 
    Debug    )

    ScalarIntUnary::equal

    source

    ScalarIntUnary::not_equal

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

    ScalarIntUnary::to_repr

    source

    SizedStackObject

    source
    pub struct SizedStackObject {
      id : Int
      size : Int
      alignment : Int
    } derive(Eq, 
    Debug    )

    A function-local stack object before target frame placement.

    SizedStackObject::equal

    source

    SizedStackObject::is_valid

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

    SizedStackObject::new

    source
    fn SizedStackObject::new(id : Int, size : Int, alignment : Int) -> SizedStackObject

    SizedStackObject::not_equal

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

    SizedStackObject::to_repr

    source

    StackArgumentTransfer

    source

    StackArgumentTransfer::equal

    source

    StackArgumentTransfer::not_equal

    source

    StackArgumentTransfer::to_repr

    source

    StackObjectRequirements

    source
    pub(all) struct StackObjectRequirements {
      size : Int
      alignment : Int
      offsets : Array[Int]
    }

    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

    SymbolicAddress

    source

    SymbolicAddress::equal

    source

    SymbolicAddress::not_equal

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

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

    TargetInstructionVerifier

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

    Operand and metadata checks for one instruction in an already verified function. The target selects the rule from its original opcode.

    TargetInstructionVerifier::atomic_compare_exchange

    source

    TargetInstructionVerifier::atomic_early_def

    source
    fn[Inst] TargetInstructionVerifier::atomic_early_def(self : TargetInstructionVerifier[Inst], message : String) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::atomic_load

    source

    TargetInstructionVerifier::atomic_rmw

    source

    TargetInstructionVerifier::atomic_store

    source

    TargetInstructionVerifier::carrier_move

    source

    TargetInstructionVerifier::conversion

    source

    TargetInstructionVerifier::float_binary

    source

    TargetInstructionVerifier::float_compare

    source

    TargetInstructionVerifier::float_ternary

    source

    TargetInstructionVerifier::float_unary

    source

    TargetInstructionVerifier::incoming_call_area_result

    source
    fn[Inst] TargetInstructionVerifier::incoming_call_area_result(self : TargetInstructionVerifier[Inst], ty : 
    ValueType    , offset : Int) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::incoming_call_result

    source

    TargetInstructionVerifier::incoming_reg

    source

    TargetInstructionVerifier::incoming_result_area

    source

    TargetInstructionVerifier::incoming_stack

    source

    TargetInstructionVerifier::internal_call

    source

    TargetInstructionVerifier::load_constant

    source

    TargetInstructionVerifier::load_float_constant

    source
    fn[Inst] TargetInstructionVerifier::load_float_constant(self : TargetInstructionVerifier[Inst], ty : 
    ValueType    , bits : UInt64) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::load_null

    source

    TargetInstructionVerifier::new

    source
    fn[Inst] TargetInstructionVerifier::new(function : Function[Inst], instruction : Instruction) -> TargetInstructionVerifier[Inst]

    TargetInstructionVerifier::outgoing_area_result

    source
    fn[Inst] TargetInstructionVerifier::outgoing_area_result(self : TargetInstructionVerifier[Inst], ty : 
    ValueType    , offset : Int) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::outgoing_reg

    source

    TargetInstructionVerifier::platform_call

    source

    TargetInstructionVerifier::reference_compare

    source

    TargetInstructionVerifier::return_shape

    source
    fn[Inst] TargetInstructionVerifier::return_shape(self : TargetInstructionVerifier[Inst]) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::safepoint_marker

    source
    fn[Inst] TargetInstructionVerifier::safepoint_marker(self : TargetInstructionVerifier[Inst]) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::scalar_load

    source

    TargetInstructionVerifier::scalar_select

    source

    TargetInstructionVerifier::scalar_store

    source

    TargetInstructionVerifier::shape

    source

    TargetInstructionVerifier::stack_address

    source
    fn[Inst] TargetInstructionVerifier::stack_address(self : TargetInstructionVerifier[Inst], valid : Bool) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::store_repeated64

    source
    fn[Inst] TargetInstructionVerifier::store_repeated64(self : TargetInstructionVerifier[Inst], offset : UInt64, count : UInt) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::switch_shape

    source

    TargetInstructionVerifier::trap

    source

    TargetInstructionVerifier::trap_if_float

    source

    TargetInstructionVerifier::trap_if_signed_div_overflow

    source

    TargetInstructionVerifier::trap_if_zero

    source

    TargetInstructionVerifier::vector_bitwise

    source

    TargetInstructionVerifier::vector_conversion

    source
    fn[Inst] TargetInstructionVerifier::vector_conversion(self : TargetInstructionVerifier[Inst], conversion : VectorConversion) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::vector_extract_lane

    source
    fn[Inst] TargetInstructionVerifier::vector_extract_lane(self : TargetInstructionVerifier[Inst], lane : 
    VectorLane    , index : Int, has_extension : Bool) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::vector_float_binary

    source

    TargetInstructionVerifier::vector_float_ternary

    source

    TargetInstructionVerifier::vector_float_unary

    source

    TargetInstructionVerifier::vector_int_binary

    source

    TargetInstructionVerifier::vector_int_compare

    source

    TargetInstructionVerifier::vector_int_shift

    source

    TargetInstructionVerifier::vector_int_unary

    source

    TargetInstructionVerifier::vector_load_extend

    source

    TargetInstructionVerifier::vector_load_lane

    source

    TargetInstructionVerifier::vector_load_zero

    source

    TargetInstructionVerifier::vector_predicate

    source

    TargetInstructionVerifier::vector_replace_lane

    source

    TargetInstructionVerifier::vector_shuffle

    source
    fn[Inst] TargetInstructionVerifier::vector_shuffle(self : TargetInstructionVerifier[Inst], mask : FixedArray[Int]) -> Unit raise TargetVCodeVerifyError

    TargetInstructionVerifier::vector_store_lane

    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

    VectorConversion

    source

    VectorConversion::equal

    source

    VectorConversion::not_equal

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

    VectorConversion::to_repr

    source

    allocation_edge_moves

    source
    fn[Inst] allocation_edge_moves(function : Function[Inst], allocation : Allocation, block : Block, successor_index : Int) -> Array[ParallelMove]

    allocation_edit_moves

    source
    fn[Inst] allocation_edit_moves(function : Function[Inst], allocation : Allocation, instruction : Instruction, placement : PointPlacement) -> Array[ParallelMove]

    call_argument_inputs

    source
    fn call_argument_inputs(operands : Array[Value], locations : ArrayView[CallArgumentLocation], is_allocatable : (
    PhysicalReg    ) -> Bool) -> Array[Input]

    call_argument_transfers

    source
    fn call_argument_transfers(allocation : Allocation, instruction : Instruction, types : Array[
    ValueType    ], locations : ArrayView[CallArgumentLocation], operand_start? : Int, stack_base? : Int, callee? : (Int, 
    PhysicalReg    ), result_area? : (Int, 
    PhysicalReg    )) -> Array[CallTransfer]

    call_stack_size

    source
    fn call_stack_size(ty : 
    ValueType    ) -> Int

    collect_frame_requirements

    source
    fn[Inst] collect_frame_requirements(function : Function[Inst], frame_use : (Inst) -> FrameUse?) -> Result[FrameRequirements, String]

    Recompute the requirements from current VCode for planning and verification.

    direct_source_metadata

    source

    Preserve the source, roots, and safepoint semantics of a selected operation.

    emit_call_stack_transfers

    source
    fn[Buffer, Frame, E : Error] emit_call_stack_transfers(plan : ResolvedCallTransferPlan, buffer : Buffer, frame : Frame, slot_offset : (Frame, StackSlot) -> Int?, access_stack : (Buffer, Bool, 
    ValueType    , 
    PhysicalReg    , Int) -> Unit raise E) -> Unit raise E

    Copy stack arguments before register moves can overwrite their sources.

    emit_incoming_values

    source
    fn[Inst, Buffer, Frame, E : Error] emit_incoming_values(function : Function[Inst], allocation : Allocation, body : ArrayView[Instruction], current_index : Int, describe : (Inst) -> (
    ValueType    , CallArgumentLocation, Int)?, buffer : Buffer, frame : Frame, stack_base : Int?, slot_offset : (Frame, StackSlot) -> Int?, stack_scratch : (
    ValueType    ) -> 
    PhysicalReg    , int_scratch : 
    PhysicalReg    , fp_scratch : 
    PhysicalReg    , emit_moves : (Buffer, Frame, ResolvedMovePlan) -> Unit raise E, access_stack : (Buffer, Bool, 
    ValueType    , 
    PhysicalReg    , Int) -> Unit raise E, invalid_moves : (MoveResolveError) -> E, missing_stack_area : E) -> Unit raise E

    Receive one contiguous group of ABI inputs. Register transfers must finish before stack loads can reuse the target's scratch registers. The target describes each pseudo as (type, incoming location, value-home operand).

    emit_resolved_moves

    source
    fn[Buffer, Frame, E : Error] emit_resolved_moves(plan : ResolvedMovePlan, buffer : Buffer, frame : Frame, slot_offset : (Frame, StackSlot) -> Int?, emergency_offset : (Frame) -> Int?, move_register : (Buffer, 
    ValueType    , 
    PhysicalReg    , 
    PhysicalReg    ) -> Unit, access_stack : (Buffer, Bool, 
    ValueType    , 
    PhysicalReg    , Int) -> Unit raise E, unresolved_stack_move : E, missing_emergency_area : E) -> Unit raise E

    Apply resolved physical moves using the target's register and frame instructions. Parallel moves reach this stage in dependency order.

    materialize_call_results

    source
    fn[Inst] materialize_call_results(builder : CheckedBuilder[Inst], block : Block, result_types : Array[
    ValueType    ], locations : ArrayView[CallResultLocation], live_gc_roots : Array[Value], incoming_register : (
    ValueType    , 
    PhysicalReg    ) -> Inst, incoming_area : (
    ValueType    , Int) -> Inst, keepalive : Inst, is_allocatable : (
    PhysicalReg    ) -> Bool) -> Array[Value] raise VCodeBuildError

    Materialize stable result homes before extending the call's root lifetimes. The target provides its register, result-area, and keepalive pseudos.

    materialize_entry_arguments

    source

    Materialize ABI inputs into stable homes using the target's incoming pseudos. These pseudos have no implicit clobbers.

    plan_conditional_edges

    source
    fn[Inst : Eq] plan_conditional_edges(function : Function[Inst], allocation : Allocation, block : Block, instruction : Instruction, next_block : Block?, jump : Inst, integer_scratch : 
    PhysicalReg    , fp_scratch : 
    PhysicalReg    , split_false_first~ : Bool) -> ConditionalEdgeLayout raise MoveResolveError

    Resolve moves and choose an emission order. Compare the original blocks for fallthrough, and use the threaded destinations for explicit branches.

    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

    platform_call_layout

    source
    fn platform_call_layout(types : Array[
    ValueType    ], integer_registers : ArrayView[Int]) -> CallLayout

    Lay out platform arguments with the target's integer registers and eight FP slots.

    platform_result_registers

    source

    Registers in each ABI bank are assigned in result order.

    reg_class_for_value_type

    source

    require_call_argument_inputs

    source
    fn[Inst] require_call_argument_inputs(function : Function[Inst], instruction : Instruction, operand_start : Int, locations : ArrayView[CallArgumentLocation], is_allocatable : (
    PhysicalReg    ) -> Bool) -> Unit raise TargetVCodeVerifyError

    require_fixed_use

    source
    fn[Inst] require_fixed_use(function : Function[Inst], instruction : Instruction, operand_index : Int, expected : 
    PhysicalReg    ) -> Unit raise TargetVCodeVerifyError

    require_home_def

    source
    fn[Inst] require_home_def(function : Function[Inst], instruction : Instruction, operand_index : Int) -> Unit raise TargetVCodeVerifyError

    require_instruction_shape

    source
    fn[Inst] require_instruction_shape(function : Function[Inst], instruction : Instruction, use_types : Array[
    ValueType    ], def_types : Array[
    ValueType    ], terminator : Bool, successor_count : Int) -> Unit raise TargetVCodeVerifyError

    require_tail_call_plan

    source
    fn[Inst] require_tail_call_plan(function : Function[Inst], instruction : Instruction, signature : 
    Signature    , plan : InternalCallPlan, indirect : Bool, is_allocatable : (
    PhysicalReg    ) -> Bool, expected_clobbers : Array[
    PhysicalReg    ]) -> Unit raise TargetVCodeVerifyError

    requires_emergency_move_area

    source
    fn[Inst] requires_emergency_move_area(function : Function[Inst], allocation : Allocation, is_abi_materialization : (Inst) -> Bool, int_scratch : 
    PhysicalReg    , fp_scratch : 
    PhysicalReg    ) -> Bool raise MoveResolveError

    resolve_edge_moves

    source
    fn[Inst] resolve_edge_moves(function : Function[Inst], allocation : Allocation, block : Block, successor_index : Int, integer_scratch : 
    PhysicalReg    , fp_scratch : 
    PhysicalReg    ) -> ResolvedMovePlan raise MoveResolveError

    Resolve the parallel moves attached to one allocated successor edge.

    select_condition

    source

    select_reference_condition

    source

    select_vector_conversion

    source

    threaded_branch_target

    source
    fn[Inst : Eq] threaded_branch_target(function : Function[Inst], allocation : Allocation, target : Block, jump : Inst, integer_scratch : 
    PhysicalReg    , fp_scratch : 
    PhysicalReg    ) -> Block raise MoveResolveError

    Chase short chains of unconditional forwarding edges. A block can only be bypassed if it has no body, no terminator edits, and no resolved edge moves. Each target still checks the displacement of its final branch encoding.

    used_callee_saved_registers

    source

    verify_abi_materialization

    source
    fn[Inst] verify_abi_materialization(function : Function[Inst], classify : (Inst) -> AbiMaterialization, platform_results : (Array[
    ValueType    ]) -> Array[
    PhysicalReg    ]) -> Unit raise TargetVCodeVerifyError

    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