🥮 mooncakes.io
    Sign in

    Milky2018/machv/vcode does not have a README file

    SafepointKind

    source

    ValueType

    source

    Exact target-neutral value types carried by semantic MachV SSA values.

    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)
      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
    pub suberror MoveResolveError {
      MissingScratch(class~ : RegClass)
      InvalidScratch(reg~ : PhysicalReg, expected~ : RegClass)
      NoSafeCycleScratch(class~ : RegClass)
      BrokenCycle
    } derive(Eq, 
    Debug    )

    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)
      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::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
    fn Allocation::stack_slot_type(self : Allocation, slot : StackSlot) -> 
    ValueType    ?

    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.

    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
    fn[Inst] Builder::new_with_protocol(name : String, protocol : 
    CallProtocol    , parameter_types : Array[
    ValueType    ], result_types : Array[
    ValueType    ]) -> Builder[Inst]

    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
    fn CallTransfer::to_register(ty : 
    ValueType    , source : Location, destination : PhysicalReg) -> CallTransfer

    CallTransfer::to_stack

    source
    fn CallTransfer::to_stack(ty : 
    ValueType    , source : Location, offset : Int) -> CallTransfer

    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

    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
    fn Edit::register_move(point : ProgramPoint, value : Value, from : PhysicalReg, to : PhysicalReg) -> Edit

    Edit::reload

    source
    fn Edit::reload(point : ProgramPoint, value : Value, slot : StackSlot, reg : PhysicalReg) -> Edit

    Edit::spill

    source
    fn Edit::spill(point : ProgramPoint, value : Value, reg : PhysicalReg, slot : StackSlot) -> Edit

    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::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_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_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_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_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::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
    fn[Inst] Function::protocol(self : Function[Inst]) -> 
    CallProtocol

    Function::result_types

    source
    fn[Inst] Function::result_types(self : Function[Inst]) -> Array[
    ValueType    ]

    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
    pub struct Input {
      value : Value
      constraint : OperandConstraint
      preference : PhysicalReg?
      timing : OperandTiming
    }

    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
    fn Input::fixed(value : Value, reg : PhysicalReg) -> Input

    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
    fn Input::with_timing(self : Input, timing : OperandTiming) -> Input

    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

    InstructionMetadata::empty

    source

    InstructionMetadata::new

    source

    InstructionMetadata::safepoint

    source
    fn InstructionMetadata::safepoint(live_gc_roots : Array[Value]) -> InstructionMetadata

    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
    pub struct Operand {
      value : Value
      role : OperandRole
      constraint : OperandConstraint
      preference : PhysicalReg?
      timing : OperandTiming
      tie_id : Int
    } derive(Eq, 
    Debug    )

    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

    OperandRole

    source
    pub(all) enum OperandRole {
      Use
      Def
    } derive(Eq, 
    Debug    )

    OperandRole::equal

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

    OperandRole::not_equal

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

    OperandRole::to_repr

    source

    OperandTiming

    source
    pub(all) enum OperandTiming {
      Early
      Late
    } derive(Eq, 
    Debug    )

    OperandTiming::equal

    source

    OperandTiming::not_equal

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

    OperandTiming::to_repr

    source

    Output

    source
    pub struct Output {
      ty : 
    ValueType
      constraint : OperandConstraint
      preference : PhysicalReg?
      timing : OperandTiming
    }

    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
    fn Output::with_preference(self : Output, preference : PhysicalReg) -> Output

    Prefer a physical register without making it an allocation constraint.

    Output::with_timing

    source
    fn Output::with_timing(self : Output, timing : OperandTiming) -> Output

    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

    PhysicalReg

    source
    pub struct PhysicalReg {
      id : Int
      class : RegClass
    } derive(Eq)

    PhysicalReg::equal

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

    PhysicalReg::new

    source
    fn PhysicalReg::new(id : Int, class : RegClass) -> PhysicalReg

    PhysicalReg::not_equal

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

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

    RegClass

    source
    pub(all) enum RegClass {
      Int
      FpVector
    } derive(Eq, Hash, 
    Debug    )

    RegClass::equal

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

    RegClass::hash

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

    RegClass::hash_combine

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

    RegClass::not_equal

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

    RegClass::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
    pub(all) enum ResolvedMoveStep {
      Transfer(ParallelMove)
      SpillScratchToEmergency(ty~ : 
    ValueType    , scratch~ : PhysicalReg)
      ReloadScratchFromEmergency(ty~ : 
    ValueType    , scratch~ : PhysicalReg)
    } derive(Eq, 
    Debug    )

    ResolvedMoveStep::equal

    source

    ResolvedMoveStep::not_equal

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

    ResolvedMoveStep::to_repr

    source

    StackArgumentTransfer

    source
    pub struct StackArgumentTransfer {
      ty : 
    ValueType
      source : Location
      offset : Int
      scratch : PhysicalReg?
    } derive(Eq, 
    Debug    )

    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 {
      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
    fn plan_parallel_moves(moves : Array[ParallelMove], scratch_int : PhysicalReg, scratch_fp : PhysicalReg) -> ResolvedMovePlan raise MoveResolveError

    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
    fn reg_class_for_value_type(ty : 
    ValueType    ) -> RegClass

    resolve_parallel_moves

    source
    fn resolve_parallel_moves(moves : Array[ParallelMove], scratch_int : Array[PhysicalReg], scratch_fp : Array[PhysicalReg]) -> Array[ParallelMove] raise MoveResolveError

    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