mooncakes.io

README
U
AllocationConstraint
U
AllocationLocation
U
AllocationOperand
U
AllocationVirtualReg
U
OperandRole
U
OperandTiming
U
PhysicalReg
U
RegClass
U
SafepointKind
U
ValueType
- ::equalAllocationVerifyError::equal
- ::not_equalAllocationVerifyError::not_equal
- ::outputAllocationVerifyError::output
- ::to_reprAllocationVerifyError::to_repr
- ::to_stringAllocationVerifyError::to_string
- ::equalCallTransferError::equal
- ::not_equalCallTransferError::not_equal
- ::to_reprCallTransferError::to_repr
- ::equalEmissionVerifyError::equal
- ::not_equalEmissionVerifyError::not_equal
- ::outputEmissionVerifyError::output
- ::to_reprEmissionVerifyError::to_repr
- ::to_stringEmissionVerifyError::to_string
- ::equalFrameVerifyError::equal
- ::not_equalFrameVerifyError::not_equal
- ::outputFrameVerifyError::output
- ::to_reprFrameVerifyError::to_repr
- ::to_stringFrameVerifyError::to_string
- ::equalMoveResolveError::equal
- ::not_equalMoveResolveError::not_equal
- ::outputMoveResolveError::output
- ::to_reprMoveResolveError::to_repr
- ::to_stringMoveResolveError::to_string
- ::equalVCodeBuildError::equal
- ::not_equalVCodeBuildError::not_equal
- ::outputVCodeBuildError::output
- ::to_reprVCodeBuildError::to_repr
- ::to_stringVCodeBuildError::to_string
- ::equalVCodeVerifyError::equal
- ::not_equalVCodeVerifyError::not_equal
- ::outputVCodeVerifyError::output
- ::to_reprVCodeVerifyError::to_repr
- ::to_stringVCodeVerifyError::to_string
- ::add_editAllocation::add_edit
- ::add_safepoint_rootAllocation::add_safepoint_root
- ::allocated_operand_location_atAllocation::allocated_operand_location_at
- ::allocated_value_location_atAllocation::allocated_value_location_at
- ::assign_operandAllocation::assign_operand
- ::assign_operand_locationAllocation::assign_operand_location
- ::assign_valueAllocation::assign_value
- ::create_stack_slotAllocation::create_stack_slot
- ::edge_edits_atAllocation::edge_edits_at
- ::edit_countAllocation::edit_count
- ::editsAllocation::edits
- ::edits_atAllocation::edits_at
- ::for_functionAllocation::for_function
- ::operand_locationAllocation::operand_location
- ::safepoint_rootsAllocation::safepoint_roots
- ::source_instruction_countAllocation::source_instruction_count
- ::stack_slot_alignmentAllocation::stack_slot_alignment
- ::stack_slot_atAllocation::stack_slot_at
- ::stack_slot_countAllocation::stack_slot_count
- ::stack_slot_sizeAllocation::stack_slot_size
- ::stack_slot_typeAllocation::stack_slot_type
- ::statisticsAllocation::statistics
- ::summaryAllocation::summary
- ::value_locationAllocation::value_location
- ::add_edge_transferAllocationBuilder::add_edge_transfer
- ::add_function_safepoint_rootsAllocationBuilder::add_function_safepoint_roots
- ::add_safepoint_rootAllocationBuilder::add_safepoint_root
- ::add_transferAllocationBuilder::add_transfer
- ::assign_operandAllocationBuilder::assign_operand
- ::assign_valueAllocationBuilder::assign_value
- ::create_stack_slotAllocationBuilder::create_stack_slot
- ::finishAllocationBuilder::finish
- ::from_plan_storageAllocationBuilder::from_plan_storage
- ::newAllocationBuilder::new
- ::operand_value_atAllocationBuilder::operand_value_at
- ::value_locationAllocationBuilder::value_location
- ::value_type_atAllocationBuilder::value_type_at
- ::equalAllocationStatistics::equal
- ::not_equalAllocationStatistics::not_equal
- ::to_reprAllocationStatistics::to_repr
- ::equalBlock::equal
- ::not_equalBlock::not_equal
- ::outputBlock::output
- ::to_reprBlock::to_repr
- ::to_stringBlock::to_string
- ::append_bodyBuilder::append_body
- ::block_parameterBuilder::block_parameter
- ::create_blockBuilder::create_block
- ::entry_blockBuilder::entry_block
- ::finishBuilder::finish
- ::newBuilder::new
- ::new_with_protocolBuilder::new_with_protocol
- ::new_with_resultsBuilder::new_with_results
- ::parameterBuilder::parameter
- ::set_terminatorBuilder::set_terminator
- ::to_registerCallTransfer::to_register
- ::to_stackCallTransfer::to_stack
- ::equalCallTransferPlan::equal
- ::not_equalCallTransferPlan::not_equal
- ::to_reprCallTransferPlan::to_repr
- ::append_bodyCheckedBuilder::append_body
- ::append_body_unconstrainedCheckedBuilder::append_body_unconstrained
- ::block_parameterCheckedBuilder::block_parameter
- ::create_blockCheckedBuilder::create_block
- ::entry_blockCheckedBuilder::entry_block
- ::finishCheckedBuilder::finish
- ::newCheckedBuilder::new
- ::new_with_protocolCheckedBuilder::new_with_protocol
- ::new_with_resultsCheckedBuilder::new_with_results
- ::parameterCheckedBuilder::parameter
- ::set_terminatorCheckedBuilder::set_terminator
- ::newEdge::new
- ::edge_moveEdit::edge_move
- ::kindEdit::kind
- ::pointEdit::point
- ::register_moveEdit::register_move
- ::reloadEdit::reload
- ::spillEdit::spill
- ::equalEditKind::equal
- ::not_equalEditKind::not_equal
- ::to_reprEditKind::to_repr
- ::alignmentFrameLayout::alignment
- ::frame_sizeFrameLayout::frame_size
- ::newFrameLayout::new
- ::place_slotFrameLayout::place_slot
- ::slot_offsetFrameLayout::slot_offset
- ::afterFunction::after
- ::allocation_block_instruction_atFunction::allocation_block_instruction_at
- ::allocation_block_instruction_countFunction::allocation_block_instruction_count
- ::allocation_block_parameter_atFunction::allocation_block_parameter_at
- ::allocation_block_parameter_countFunction::allocation_block_parameter_count
- ::allocation_block_successor_atFunction::allocation_block_successor_at
- ::allocation_block_successor_countFunction::allocation_block_successor_count
- ::allocation_edge_argument_atFunction::allocation_edge_argument_at
- ::allocation_edge_argument_countFunction::allocation_edge_argument_count
- ::allocation_entry_value_atFunction::allocation_entry_value_at
- ::allocation_instruction_clobbersFunction::allocation_instruction_clobbers
- ::allocation_instruction_operandsFunction::allocation_instruction_operands
- ::allocation_layout_block_id_atFunction::allocation_layout_block_id_at
- ::allocation_value_type_atFunction::allocation_value_type_at
- ::allocation_vregFunction::allocation_vreg
- ::beforeFunction::before
- ::block_atFunction::block_at
- ::block_bodyFunction::block_body
- ::block_countFunction::block_count
- ::block_indexFunction::block_index
- ::block_instruction_atFunction::block_instruction_at
- ::block_instruction_countFunction::block_instruction_count
- ::block_parameter_atFunction::block_parameter_at
- ::block_parameter_countFunction::block_parameter_count
- ::block_parametersFunction::block_parameters
- ::block_terminatorFunction::block_terminator
- ::entry_blockFunction::entry_block
- ::instructionFunction::instruction
- ::instruction_allocation_operand_atFunction::instruction_allocation_operand_at
- ::instruction_atFunction::instruction_at
- ::instruction_clobber_atFunction::instruction_clobber_at
- ::instruction_clobber_countFunction::instruction_clobber_count
- ::instruction_clobbersFunction::instruction_clobbers
- ::instruction_countFunction::instruction_count
- ::instruction_indexFunction::instruction_index
- ::instruction_is_terminatorFunction::instruction_is_terminator
- ::instruction_metadataFunction::instruction_metadata
- ::instruction_operand_atFunction::instruction_operand_at
- ::instruction_operand_countFunction::instruction_operand_count
- ::instruction_operandsFunction::instruction_operands
- ::instruction_resultsFunction::instruction_results
- ::instruction_successor_argument_atFunction::instruction_successor_argument_at
- ::instruction_successor_argument_countFunction::instruction_successor_argument_count
- ::instruction_successor_atFunction::instruction_successor_at
- ::instruction_successor_countFunction::instruction_successor_count
- ::instruction_successor_targetFunction::instruction_successor_target
- ::instruction_successorsFunction::instruction_successors
- ::layoutFunction::layout
- ::layout_block_atFunction::layout_block_at
- ::nameFunction::name
- ::parameter_atFunction::parameter_at
- ::parameter_countFunction::parameter_count
- ::program_point_instructionFunction::program_point_instruction
- ::protocolFunction::protocol
- ::result_typesFunction::result_types
- ::set_layoutFunction::set_layout
- ::summaryFunction::summary
- ::value_atFunction::value_at
- ::value_countFunction::value_count
- ::value_indexFunction::value_index
- ::value_typeFunction::value_type
- ::anyInput::any
- ::any_locationInput::any_location
- ::fixedInput::fixed
- ::with_preferenceInput::with_preference
- ::with_timingInput::with_timing
- ::equalInstruction::equal
- ::not_equalInstruction::not_equal
- ::outputInstruction::output
- ::to_reprInstruction::to_repr
- ::to_stringInstruction::to_string
- ::emptyInstructionMetadata::empty
- ::newInstructionMetadata::new
- ::safepointInstructionMetadata::safepoint
- ::equalLocation::equal
- ::not_equalLocation::not_equal
- ::to_reprLocation::to_repr
- ::equalOperand::equal
- ::not_equalOperand::not_equal
- ::to_reprOperand::to_repr
- ::equalOperandConstraint::equal
- ::not_equalOperandConstraint::not_equal
- ::to_reprOperandConstraint::to_repr
- ::anyOutput::any
- ::any_locationOutput::any_location
- ::fixedOutput::fixed
- ::tiedOutput::tied
- ::with_preferenceOutput::with_preference
- ::with_timingOutput::with_timing
- ::equalParallelMove::equal
- ::newParallelMove::new
- ::not_equalParallelMove::not_equal
- ::to_reprParallelMove::to_repr
- ::equalPointPlacement::equal
- ::not_equalPointPlacement::not_equal
- ::to_reprPointPlacement::to_repr
- ::equalProgramPoint::equal
- ::instructionProgramPoint::instruction
- ::not_equalProgramPoint::not_equal
- ::placementProgramPoint::placement
- ::to_reprProgramPoint::to_repr
- ::equalRegallocLoopStatistics::equal
- ::not_equalRegallocLoopStatistics::not_equal
- ::to_reprRegallocLoopStatistics::to_repr
- ::equalResolvedCallTransferPlan::equal
- ::not_equalResolvedCallTransferPlan::not_equal
- ::to_reprResolvedCallTransferPlan::to_repr
- ::emptyResolvedMovePlan::empty
- ::equalResolvedMovePlan::equal
- ::not_equalResolvedMovePlan::not_equal
- ::to_reprResolvedMovePlan::to_repr
- ::equalResolvedMoveStep::equal
- ::not_equalResolvedMoveStep::not_equal
- ::to_reprResolvedMoveStep::to_repr
- ::equalStackArgumentTransfer::equal
- ::not_equalStackArgumentTransfer::not_equal
- ::to_reprStackArgumentTransfer::to_repr
- ::equalStackSlot::equal
- ::not_equalStackSlot::not_equal
- ::to_reprStackSlot::to_repr
- ::equalSymbolReference::equal
- ::not_equalSymbolReference::not_equal
- ::to_reprSymbolReference::to_repr
- ::equalTargetCompileEvent::equal
- ::not_equalTargetCompileEvent::not_equal
- ::to_reprTargetCompileEvent::to_repr
- ::equalValue::equal
- ::not_equalValue::not_equal
- ::outputValue::output
- ::to_reprValue::to_repr
- ::to_stringValue::to_string
V
plan_call_transfers
V
plan_parallel_moves
V
plan_resolved_call_transfers
V
reg_class_for_value_type
V
resolve_parallel_moves
V
verify_allocated
V
verify_allocation_invariants
V
verify_emission_input
V
verify_framed
V
verify_selected

Milky2018/vcode/native_lowering does not have a README file

DirectLoweringError

pub suberror DirectLoweringError {
  InvalidCallAbi(message~ : String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for DirectLoweringError

DirectLoweringError::equal

source

fn DirectLoweringError::equal(DirectLoweringError, DirectLoweringError) -> Bool

DirectLoweringError::not_equal

source

fn DirectLoweringError::not_equal(x : DirectLoweringError, y : DirectLoweringError) -> Bool

DirectLoweringError::output

source

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

DirectLoweringError::to_repr

source

fn DirectLoweringError::to_repr(DirectLoweringError) -> @moonbitlang/core/debug.Repr
Repr

DirectLoweringError::to_string

source

fn DirectLoweringError::to_string(self : DirectLoweringError) -> String

AtomicRmwOp

source

pub(all) enum AtomicRmwOp {
  Add
  Sub
  And
  Or
  Xor
  Exchange
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

AtomicRmwOp::equal

source

fn AtomicRmwOp::equal(AtomicRmwOp, AtomicRmwOp) -> Bool

AtomicRmwOp::hash

source

fn AtomicRmwOp::hash(self : AtomicRmwOp) -> Int

AtomicRmwOp::hash_combine

source

fn AtomicRmwOp::hash_combine(AtomicRmwOp, Hasher) -> Unit

AtomicRmwOp::not_equal

source

fn AtomicRmwOp::not_equal(x : AtomicRmwOp, y : AtomicRmwOp) -> Bool

AtomicRmwOp::to_repr

source

fn AtomicRmwOp::to_repr(AtomicRmwOp) -> @moonbitlang/core/debug.Repr
Repr

AtomicSpec

source

pub struct AtomicSpec {
  width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth
  value_type : @Milky2018/vcode/native_types.ValueType
ValueType
  offset : UInt64
  endianness : @Milky2018/vcode/native_types.Endianness
Endianness
  trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

A sequentially consistent atomic memory access. Weaker memory orders are not part of the current native-lowering contract.

AtomicSpec::equal

source

fn AtomicSpec::equal(AtomicSpec, AtomicSpec) -> Bool

AtomicSpec::hash

source

fn AtomicSpec::hash(self : AtomicSpec) -> Int

AtomicSpec::hash_combine

source

fn AtomicSpec::hash_combine(AtomicSpec, Hasher) -> Unit

AtomicSpec::new

source

fn AtomicSpec::new(width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth, value_type : @Milky2018/vcode/native_types.ValueType
ValueType, offset : UInt64, endianness : @Milky2018/vcode/native_types.Endianness
Endianness, trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?) -> AtomicSpec

AtomicSpec::not_equal

source

fn AtomicSpec::not_equal(x : AtomicSpec, y : AtomicSpec) -> Bool

AtomicSpec::to_repr

source

fn AtomicSpec::to_repr(AtomicSpec) -> @moonbitlang/core/debug.Repr
Repr

Block

source

pub(all) struct Block {
  id : Int
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

Block::equal

source

fn Block::equal(Block, Block) -> Bool

Block::hash

source

fn Block::hash(self : Block) -> Int

Block::hash_combine

source

fn Block::hash_combine(Block, Hasher) -> Unit

Block::not_equal

source

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

Block::to_repr

source

fn Block::to_repr(Block) -> @moonbitlang/core/debug.Repr
Repr

CallAbiElaboration

source

pub struct CallAbiElaboration {
  // private fields
}

CallAbiElaboration::new

source

fn CallAbiElaboration::new(root_scope? : CallerRootScopeAbi, hidden_safepoints? : Array[HiddenSafepointAbi]) -> CallAbiElaboration

CallerRootScopeAbi

source

pub struct CallerRootScopeAbi {
  // private fields
}

CallerRootScopeAbi::new

source

fn CallerRootScopeAbi::new(push_symbol : @Milky2018/vcode/native_types.ExternalSymbol
ExternalSymbol, pop_symbol : @Milky2018/vcode/native_types.ExternalSymbol
ExternalSymbol) -> CallerRootScopeAbi

ConversionOp

source

pub(all) enum ConversionOp {
  I32WrapI64
  I64ExtendI32(@Milky2018/vcode/native_types.Signedness
Signedness)
  F32DemoteF64
  F64PromoteF32
  FloatToInt(@Milky2018/vcode/native_types.FloatType
FloatType, @Milky2018/vcode/native_types.IntegerType
IntegerType, @Milky2018/vcode/native_types.Signedness
Signedness, @Milky2018/vcode/native_types.ConversionMode
ConversionMode)
  IntToFloat(@Milky2018/vcode/native_types.IntegerType
IntegerType, @Milky2018/vcode/native_types.FloatType
FloatType, @Milky2018/vcode/native_types.Signedness
Signedness)
  SignExtend(@Milky2018/vcode/native_types.IntegerType
IntegerType, @Milky2018/vcode/native_types.AccessWidth
AccessWidth)
  Bitcast(@Milky2018/vcode/native_types.ValueType
ValueType, @Milky2018/vcode/native_types.ValueType
ValueType)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

ConversionOp::equal

source

fn ConversionOp::equal(ConversionOp, ConversionOp) -> Bool

ConversionOp::hash

source

fn ConversionOp::hash(self : ConversionOp) -> Int

ConversionOp::hash_combine

source

fn ConversionOp::hash_combine(ConversionOp, Hasher) -> Unit

ConversionOp::not_equal

source

fn ConversionOp::not_equal(x : ConversionOp, y : ConversionOp) -> Bool

ConversionOp::to_repr

source

fn ConversionOp::to_repr(ConversionOp) -> @moonbitlang/core/debug.Repr
Repr

DirectBuilder

source

pub struct DirectBuilder {
  // private fields
}

Streaming construction state. It tracks handle types and one pending terminator, but never stores instructions, uses, CFG edges, or SSA definitions.

DirectBuilder::block_parameters

source

fn DirectBuilder::block_parameters(self : DirectBuilder, block : Block) -> Array[Value]

DirectBuilder::branch

source

fn DirectBuilder::branch(self : DirectBuilder, condition : Value, true_target : Block, true_arguments : Array[Value], false_target : Block, false_arguments : Array[Value]) -> Unit

DirectBuilder::branch_int_compare

source

fn DirectBuilder::branch_int_compare(self : DirectBuilder, comparison : IntComparison, left : Value, right : Value, true_target : Block, true_arguments : Array[Value], false_target : Block, false_arguments : Array[Value]) -> Unit

DirectBuilder::branch_int_compare_immediate

source

fn DirectBuilder::branch_int_compare_immediate(self : DirectBuilder, comparison : IntComparison, input : Value, bits : UInt64, true_target : Block, true_arguments : Array[Value], false_target : Block, false_arguments : Array[Value]) -> Unit

DirectBuilder::create_block

source

fn DirectBuilder::create_block(self : DirectBuilder, parameter_types : Array[@Milky2018/vcode/native_types.ValueType
ValueType]) -> Block

DirectBuilder::create_stack_object

source

fn DirectBuilder::create_stack_object(self : DirectBuilder, size : Int, alignment : Int) -> @Milky2018/vcode/native_types.StackObject
StackObject

DirectBuilder::emit_with_metadata

source

fn DirectBuilder::emit_with_metadata(self : DirectBuilder, operation : Operation, operands : Array[Value], result_types : Array[@Milky2018/vcode/native_types.ValueType
ValueType], metadata : InstructionMetadata) -> Array[Value]

DirectBuilder::entry_block

source

fn DirectBuilder::entry_block(self : DirectBuilder) -> Block

DirectBuilder::finish

source

fn DirectBuilder::finish(self : DirectBuilder) -> Unit raise DirectLoweringError

DirectBuilder::jump

source

fn DirectBuilder::jump(self : DirectBuilder, target : Block, arguments : Array[Value]) -> Unit

DirectBuilder::new

source

fn DirectBuilder::new(parameter_types : Array[@Milky2018/vcode/native_types.ValueType
ValueType], sink : TargetSink, call_abi? : CallAbiElaboration, root_scope_capacity? : Int) -> DirectBuilder

DirectBuilder::noreturn_call_with_metadata

source

fn DirectBuilder::noreturn_call_with_metadata(self : DirectBuilder, call : @Milky2018/vcode/native_types.NativeCall
NativeCall, operands : Array[Value], metadata : TerminatorMetadata) -> Unit

DirectBuilder::parameters

source

fn DirectBuilder::parameters(self : DirectBuilder) -> Array[Value]

DirectBuilder::return_

source

fn DirectBuilder::return_(self : DirectBuilder, values : Array[Value]) -> Unit

DirectBuilder::set_terminator_source

source

fn DirectBuilder::set_terminator_source(self : DirectBuilder, source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation) -> Unit

DirectBuilder::switch

source

fn DirectBuilder::switch(self : DirectBuilder, value : Value, cases : Array[(UInt64, Block, Array[Value])], default_target : Block, default_arguments : Array[Value]) -> Unit

DirectBuilder::switch_to_block

source

fn DirectBuilder::switch_to_block(self : DirectBuilder, block : Block) -> Unit

DirectBuilder::tail_call_with_metadata

source

fn DirectBuilder::tail_call_with_metadata(self : DirectBuilder, call : @Milky2018/vcode/native_types.NativeCall
NativeCall, operands : Array[Value], metadata : TerminatorMetadata) -> Unit

DirectBuilder::trap

source

fn DirectBuilder::trap(self : DirectBuilder, reason : @Milky2018/vcode/native_types.TrapReason
TrapReason) -> Unit

DirectBuilder::value_type

source

fn DirectBuilder::value_type(self : DirectBuilder, value : Value) -> @Milky2018/vcode/native_types.ValueType
ValueType?

FloatBinaryOp

source

pub(all) enum FloatBinaryOp {
  Add
  Sub
  Mul
  Div
  Min
  Max
  CopySign
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

FloatBinaryOp::equal

source

fn FloatBinaryOp::equal(FloatBinaryOp, FloatBinaryOp) -> Bool

FloatBinaryOp::hash

source

fn FloatBinaryOp::hash(self : FloatBinaryOp) -> Int

FloatBinaryOp::hash_combine

source

fn FloatBinaryOp::hash_combine(FloatBinaryOp, Hasher) -> Unit

FloatBinaryOp::not_equal

source

fn FloatBinaryOp::not_equal(x : FloatBinaryOp, y : FloatBinaryOp) -> Bool

FloatBinaryOp::to_repr

source

fn FloatBinaryOp::to_repr(FloatBinaryOp) -> @moonbitlang/core/debug.Repr
Repr

FloatComparison

source

pub(all) enum FloatComparison {
  Equal
  NotEqual
  LessThan
  LessOrEqual
  GreaterThan
  GreaterOrEqual
  Ordered
  Unordered
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

FloatComparison::equal

source

fn FloatComparison::equal(FloatComparison, FloatComparison) -> Bool

FloatComparison::hash

source

fn FloatComparison::hash(self : FloatComparison) -> Int

FloatComparison::hash_combine

source

fn FloatComparison::hash_combine(FloatComparison, Hasher) -> Unit

FloatComparison::not_equal

source

fn FloatComparison::not_equal(x : FloatComparison, y : FloatComparison) -> Bool

FloatComparison::to_repr

source

fn FloatComparison::to_repr(FloatComparison) -> @moonbitlang/core/debug.Repr
Repr

FloatTernaryOp

source

pub(all) enum FloatTernaryOp {
  FusedMultiplyAdd
  FusedNegatedMultiplyAdd
  FusedMultiplySubtract
  FusedNegatedMultiplySubtract
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

FloatTernaryOp::equal

source

fn FloatTernaryOp::equal(FloatTernaryOp, FloatTernaryOp) -> Bool

FloatTernaryOp::hash

source

fn FloatTernaryOp::hash(self : FloatTernaryOp) -> Int

FloatTernaryOp::hash_combine

source

fn FloatTernaryOp::hash_combine(FloatTernaryOp, Hasher) -> Unit

FloatTernaryOp::not_equal

source

fn FloatTernaryOp::not_equal(x : FloatTernaryOp, y : FloatTernaryOp) -> Bool

FloatTernaryOp::to_repr

source

fn FloatTernaryOp::to_repr(FloatTernaryOp) -> @moonbitlang/core/debug.Repr
Repr

FloatUnaryOp

source

pub(all) enum FloatUnaryOp {
  Negate
  Absolute
  SquareRoot
  Ceil
  Floor
  Truncate
  Nearest
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

FloatUnaryOp::equal

source

fn FloatUnaryOp::equal(FloatUnaryOp, FloatUnaryOp) -> Bool

FloatUnaryOp::hash

source

fn FloatUnaryOp::hash(self : FloatUnaryOp) -> Int

FloatUnaryOp::hash_combine

source

fn FloatUnaryOp::hash_combine(FloatUnaryOp, Hasher) -> Unit

FloatUnaryOp::not_equal

source

fn FloatUnaryOp::not_equal(x : FloatUnaryOp, y : FloatUnaryOp) -> Bool

FloatUnaryOp::to_repr

source

fn FloatUnaryOp::to_repr(FloatUnaryOp) -> @moonbitlang/core/debug.Repr
Repr

HiddenSafepointAbi

source

pub struct HiddenSafepointAbi {
  // private fields
}

HiddenSafepointAbi::new

source

fn HiddenSafepointAbi::new(symbol : @Milky2018/vcode/native_types.ExternalSymbol
ExternalSymbol, argument_roots : StackMapArgumentRoots) -> HiddenSafepointAbi

InstructionMetadata

source

pub(all) struct InstructionMetadata {
  source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation?
  live_gc_roots : Array[Value]
  stack_map : @Milky2018/vcode/native_types.StackMapMetadata
StackMapMetadata?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

InstructionMetadata::empty

source

fn InstructionMetadata::empty() -> InstructionMetadata

InstructionMetadata::equal

source

fn InstructionMetadata::equal(InstructionMetadata, InstructionMetadata) -> Bool

InstructionMetadata::new

source

fn InstructionMetadata::new(source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation?, live_gc_roots : Array[Value], stack_map? : @Milky2018/vcode/native_types.StackMapMetadata
StackMapMetadata) -> InstructionMetadata

InstructionMetadata::not_equal

source

fn InstructionMetadata::not_equal(x : InstructionMetadata, y : InstructionMetadata) -> Bool

InstructionMetadata::to_repr

source

fn InstructionMetadata::to_repr(InstructionMetadata) -> @moonbitlang/core/debug.Repr
Repr

IntBinaryOp

source

pub(all) enum IntBinaryOp {
  Add
  Sub
  Mul
  SignedDiv
  UnsignedDiv
  SignedRem
  UnsignedRem
  And
  Or
  Xor
  ShiftLeft
  SignedShiftRight
  UnsignedShiftRight
  RotateLeft
  RotateRight
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

IntBinaryOp::equal

source

fn IntBinaryOp::equal(IntBinaryOp, IntBinaryOp) -> Bool

IntBinaryOp::hash

source

fn IntBinaryOp::hash(self : IntBinaryOp) -> Int

IntBinaryOp::hash_combine

source

fn IntBinaryOp::hash_combine(IntBinaryOp, Hasher) -> Unit

IntBinaryOp::not_equal

source

fn IntBinaryOp::not_equal(x : IntBinaryOp, y : IntBinaryOp) -> Bool

IntBinaryOp::to_repr

source

fn IntBinaryOp::to_repr(IntBinaryOp) -> @moonbitlang/core/debug.Repr
Repr

IntComparison

source

pub(all) enum IntComparison {
  Equal
  NotEqual
  SignedLessThan
  SignedLessOrEqual
  SignedGreaterThan
  SignedGreaterOrEqual
  UnsignedLessThan
  UnsignedLessOrEqual
  UnsignedGreaterThan
  UnsignedGreaterOrEqual
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

IntComparison::equal

source

fn IntComparison::equal(IntComparison, IntComparison) -> Bool

IntComparison::hash

source

fn IntComparison::hash(self : IntComparison) -> Int

IntComparison::hash_combine

source

fn IntComparison::hash_combine(IntComparison, Hasher) -> Unit

IntComparison::not_equal

source

fn IntComparison::not_equal(x : IntComparison, y : IntComparison) -> Bool

IntComparison::to_repr

source

fn IntComparison::to_repr(IntComparison) -> @moonbitlang/core/debug.Repr
Repr

IntOverflowOp

source

pub(all) enum IntOverflowOp {
  Add(@Milky2018/vcode/native_types.Signedness
Signedness)
  Sub(@Milky2018/vcode/native_types.Signedness
Signedness)
  Mul(@Milky2018/vcode/native_types.Signedness
Signedness)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

IntOverflowOp::equal

source

fn IntOverflowOp::equal(IntOverflowOp, IntOverflowOp) -> Bool

IntOverflowOp::hash

source

fn IntOverflowOp::hash(self : IntOverflowOp) -> Int

IntOverflowOp::hash_combine

source

fn IntOverflowOp::hash_combine(IntOverflowOp, Hasher) -> Unit

IntOverflowOp::not_equal

source

fn IntOverflowOp::not_equal(x : IntOverflowOp, y : IntOverflowOp) -> Bool

IntOverflowOp::to_repr

source

fn IntOverflowOp::to_repr(IntOverflowOp) -> @moonbitlang/core/debug.Repr
Repr

IntUnaryOp

source

pub(all) enum IntUnaryOp {
  Not
  CountLeadingZeros
  CountTrailingZeros
  PopulationCount
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

IntUnaryOp::equal

source

fn IntUnaryOp::equal(IntUnaryOp, IntUnaryOp) -> Bool

IntUnaryOp::hash

source

fn IntUnaryOp::hash(self : IntUnaryOp) -> Int

IntUnaryOp::hash_combine

source

fn IntUnaryOp::hash_combine(IntUnaryOp, Hasher) -> Unit

IntUnaryOp::not_equal

source

fn IntUnaryOp::not_equal(x : IntUnaryOp, y : IntUnaryOp) -> Bool

IntUnaryOp::to_repr

source

fn IntUnaryOp::to_repr(IntUnaryOp) -> @moonbitlang/core/debug.Repr
Repr

LoadSpec

source

pub struct LoadSpec {
  width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth
  extension : @Milky2018/vcode/native_types.LoadExtension
LoadExtension
  result_type : @Milky2018/vcode/native_types.ValueType
ValueType
  offset : UInt64
  endianness : @Milky2018/vcode/native_types.Endianness
Endianness
  trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

LoadSpec::equal

source

fn LoadSpec::equal(LoadSpec, LoadSpec) -> Bool

LoadSpec::hash

source

fn LoadSpec::hash(self : LoadSpec) -> Int

LoadSpec::hash_combine

source

fn LoadSpec::hash_combine(LoadSpec, Hasher) -> Unit

LoadSpec::new

source

fn LoadSpec::new(width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth, extension : @Milky2018/vcode/native_types.LoadExtension
LoadExtension, result_type : @Milky2018/vcode/native_types.ValueType
ValueType, offset : UInt64, endianness : @Milky2018/vcode/native_types.Endianness
Endianness, trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?) -> LoadSpec

LoadSpec::not_equal

source

fn LoadSpec::not_equal(x : LoadSpec, y : LoadSpec) -> Bool

LoadSpec::to_repr

source

fn LoadSpec::to_repr(LoadSpec) -> @moonbitlang/core/debug.Repr
Repr

Operation

source

pub(all) enum Operation {
  I32Const(UInt)
  I64Const(UInt64)
  F32Const(UInt)
  F64Const(UInt64)
  V128Const(UInt64, UInt64)
  NullPtr
  NullGcRef
  CodeAddress(@Milky2018/vcode/native_types.CodeSymbol
CodeSymbol)
  ExternalAddress(@Milky2018/vcode/native_types.ExternalSymbol
ExternalSymbol)
  DataAddress(@Milky2018/vcode/native_types.DataSymbol
DataSymbol)
  EnvironmentField(@Milky2018/vcode/native_types.EnvironmentField
EnvironmentField, @Milky2018/vcode/native_types.EnvironmentFieldStability
EnvironmentFieldStability)
  StackAddress(@Milky2018/vcode/native_types.StackObject
StackObject)
  Copy
  Select
  SpectreGuard
  GcRefAddress
  GcRefFromBits
  PointerOffset
  ReferenceCompare(ReferenceComparison)
  IntUnary(IntUnaryOp)
  IntBinary(IntBinaryOp)
  IntBinaryImmediate(IntBinaryOp, UInt64)
  IntShiftImmediate(IntBinaryOp, Int)
  IntMultiplyAdd
  IntAddShiftedLeft(Int)
  IntHighMultiply(@Milky2018/vcode/native_types.Signedness
Signedness)
  IntWithOverflow(IntOverflowOp)
  IntCompare(IntComparison)
  FloatUnary(FloatUnaryOp)
  FloatBinary(FloatBinaryOp)
  FloatTernary(FloatTernaryOp)
  FloatCompare(FloatComparison)
  Convert(ConversionOp)
  Load(LoadSpec)
  LoadIndexed(LoadSpec, Int)
  Store(StoreSpec)
  StoreIndexed(StoreSpec, Int)
  AtomicLoad(AtomicSpec)
  AtomicStore(AtomicSpec)
  AtomicRmw(AtomicSpec, AtomicRmwOp)
  AtomicCompareExchange(AtomicSpec)
  AtomicFence
  Vector(VectorOp)
  VectorLoad(VectorLoadSpec)
  VectorStoreLane(VectorStoreLaneSpec)
  Call(@Milky2018/vcode/native_types.NativeCall
NativeCall)
  Safepoint(@Milky2018/vcode/native_types.SafepointKind
SafepointKind)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Operation::copy

source

fn Operation::copy(self : Operation) -> Operation

Operation::equal

source

fn Operation::equal(Operation, Operation) -> Bool

Operation::not_equal

source

fn Operation::not_equal(x : Operation, y : Operation) -> Bool

Operation::semantics

source

fn Operation::semantics(self : Operation) -> @Milky2018/vcode/native_types.OperationSemantics
OperationSemantics

Operation::to_repr

source

fn Operation::to_repr(Operation) -> @moonbitlang/core/debug.Repr
Repr

ReferenceComparison

source

pub(all) enum ReferenceComparison {
  Equal
  NotEqual
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

ReferenceComparison::equal

source

fn ReferenceComparison::equal(ReferenceComparison, ReferenceComparison) -> Bool

ReferenceComparison::hash

source

fn ReferenceComparison::hash(self : ReferenceComparison) -> Int

ReferenceComparison::hash_combine

source

fn ReferenceComparison::hash_combine(ReferenceComparison, Hasher) -> Unit

ReferenceComparison::not_equal

source

fn ReferenceComparison::not_equal(x : ReferenceComparison, y : ReferenceComparison) -> Bool

ReferenceComparison::to_repr

source

fn ReferenceComparison::to_repr(ReferenceComparison) -> @moonbitlang/core/debug.Repr
Repr

StackMapArgumentRoots

source

pub(all) enum StackMapArgumentRoots {
  Fixed(Int)
  I32ConstantOperand(Int)
  AllocationOperands
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

How a hidden safepoint describes GC roots already present in its arguments.

StackMapArgumentRoots::equal

source

fn StackMapArgumentRoots::equal(StackMapArgumentRoots, StackMapArgumentRoots) -> Bool

StackMapArgumentRoots::not_equal

source

fn StackMapArgumentRoots::not_equal(x : StackMapArgumentRoots, y : StackMapArgumentRoots) -> Bool

StackMapArgumentRoots::to_repr

source

fn StackMapArgumentRoots::to_repr(StackMapArgumentRoots) -> @moonbitlang/core/debug.Repr
Repr

StoreSpec

source

pub struct StoreSpec {
  width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth
  value_type : @Milky2018/vcode/native_types.ValueType
ValueType
  offset : UInt64
  endianness : @Milky2018/vcode/native_types.Endianness
Endianness
  trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

StoreSpec::equal

source

fn StoreSpec::equal(StoreSpec, StoreSpec) -> Bool

StoreSpec::hash

source

fn StoreSpec::hash(self : StoreSpec) -> Int

StoreSpec::hash_combine

source

fn StoreSpec::hash_combine(StoreSpec, Hasher) -> Unit

StoreSpec::new

source

fn StoreSpec::new(width : @Milky2018/vcode/native_types.AccessWidth
AccessWidth, value_type : @Milky2018/vcode/native_types.ValueType
ValueType, offset : UInt64, endianness : @Milky2018/vcode/native_types.Endianness
Endianness, trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?) -> StoreSpec

StoreSpec::not_equal

source

fn StoreSpec::not_equal(x : StoreSpec, y : StoreSpec) -> Bool

StoreSpec::to_repr

source

fn StoreSpec::to_repr(StoreSpec) -> @moonbitlang/core/debug.Repr
Repr

SwitchCase

source

pub(all) struct SwitchCase {
  bits : UInt64
  target : Block
  arguments : Array[Value]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

SwitchCase::equal

source

fn SwitchCase::equal(SwitchCase, SwitchCase) -> Bool

SwitchCase::not_equal

source

fn SwitchCase::not_equal(x : SwitchCase, y : SwitchCase) -> Bool

SwitchCase::to_repr

source

fn SwitchCase::to_repr(SwitchCase) -> @moonbitlang/core/debug.Repr
Repr

TargetSink

source

pub struct TargetSink {
  // private fields
}

Target-owned callbacks. Integer ids refer to target VCode values, blocks, and stack-object requests; DirectBuilder is the only component that exposes typed transient handles to legalization code.

TargetSink::folds_unsigned_index_into_memory

source

fn TargetSink::folds_unsigned_index_into_memory(self : TargetSink) -> Bool

Whether an indexed memory operation consumes an unsigned 32-bit index without materializing a separate extension and address addition.

TargetSink::new

source

fn TargetSink::new(parameters : () -> Array[Int], entry_block : () -> Int, create_block : (Array[@Milky2018/vcode/native_types.ValueType
ValueType]) -> (Int, Array[Int]), create_stack_object : (Int, Int) -> Int, switch_to_block : (Int) -> Unit, emit : (Int, Operation, Array[Int], Array[@Milky2018/vcode/native_types.ValueType
ValueType], @Milky2018/vcode/native_types.SourceLocation
SourceLocation?, Array[Int], @Milky2018/vcode/native_types.StackMapMetadata
StackMapMetadata?) -> Array[Int], terminate : (Int, TargetTerminator, TargetTerminatorMetadata) -> Unit, finish : () -> Unit, folds_unsigned_index_into_memory? : Bool) -> TargetSink

TargetSwitchCase

source

pub(all) struct TargetSwitchCase {
  bits : UInt64
  target : Int
  arguments : Array[Int]
}

TargetTerminator

source

pub(all) enum TargetTerminator {
  Jump(Int, Array[Int])
  Branch(Int, Int, Array[Int], Int, Array[Int])
  BranchIntCompare(IntComparison, Int, Int, Int, Array[Int], Int, Array[Int])
  BranchIntCompareImmediate(IntComparison, Int, UInt64, Int, Array[Int], Int, Array[Int])
  Switch(Int, Array[TargetSwitchCase], Int, Array[Int])
  Return(Array[Int])
  TailCall(@Milky2018/vcode/native_types.NativeCall
NativeCall, Array[Int])
  NoReturnCall(@Milky2018/vcode/native_types.NativeCall
NativeCall, Array[Int])
  Trap(@Milky2018/vcode/native_types.TrapReason
TrapReason)
}

TargetTerminatorMetadata

source

pub(all) struct TargetTerminatorMetadata {
  source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation?
  live_gc_roots : Array[Int]
}

Terminator

source

pub(all) enum Terminator {
  Jump(Block, Array[Value])
  Branch(Value, Block, Array[Value], Block, Array[Value])
  BranchIntCompare(IntComparison, Value, Value, Block, Array[Value], Block, Array[Value])
  BranchIntCompareImmediate(IntComparison, Value, UInt64, Block, Array[Value], Block, Array[Value])
  Switch(Value, Array[SwitchCase], Block, Array[Value])
  Return(Array[Value])
  TailCall(@Milky2018/vcode/native_types.NativeCall
NativeCall, Array[Value])
  NoReturnCall(@Milky2018/vcode/native_types.NativeCall
NativeCall, Array[Value])
  Trap(@Milky2018/vcode/native_types.TrapReason
TrapReason)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Terminator::equal

source

fn Terminator::equal(Terminator, Terminator) -> Bool

Terminator::not_equal

source

fn Terminator::not_equal(x : Terminator, y : Terminator) -> Bool

Terminator::to_repr

source

fn Terminator::to_repr(Terminator) -> @moonbitlang/core/debug.Repr
Repr

TerminatorMetadata

source

pub(all) struct TerminatorMetadata {
  source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation?
  live_gc_roots : Array[Value]
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

TerminatorMetadata::equal

source

fn TerminatorMetadata::equal(TerminatorMetadata, TerminatorMetadata) -> Bool

TerminatorMetadata::new

source

fn TerminatorMetadata::new(source : @Milky2018/vcode/native_types.SourceLocation
SourceLocation?, live_gc_roots : Array[Value]) -> TerminatorMetadata

TerminatorMetadata::not_equal

source

fn TerminatorMetadata::not_equal(x : TerminatorMetadata, y : TerminatorMetadata) -> Bool

TerminatorMetadata::to_repr

source

fn TerminatorMetadata::to_repr(TerminatorMetadata) -> @moonbitlang/core/debug.Repr
Repr

Value

source

pub(all) struct Value {
  id : Int
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

Opaque handles used only while one MilkIR function is streamed into a target selector. They do not own an SSA graph.

Value::equal

source

fn Value::equal(Value, Value) -> Bool

Value::hash

source

fn Value::hash(self : Value) -> Int

Value::hash_combine

source

fn Value::hash_combine(Value, Hasher) -> Unit

Value::not_equal

source

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

Value::to_repr

source

fn Value::to_repr(Value) -> @moonbitlang/core/debug.Repr
Repr

VectorBitwiseOp

source

pub(all) enum VectorBitwiseOp {
  Not
  And
  Or
  Xor
  AndNot
  BitSelect
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorBitwiseOp::equal

source

fn VectorBitwiseOp::equal(VectorBitwiseOp, VectorBitwiseOp) -> Bool

VectorBitwiseOp::hash

source

fn VectorBitwiseOp::hash(self : VectorBitwiseOp) -> Int

VectorBitwiseOp::hash_combine

source

fn VectorBitwiseOp::hash_combine(VectorBitwiseOp, Hasher) -> Unit

VectorBitwiseOp::not_equal

source

fn VectorBitwiseOp::not_equal(x : VectorBitwiseOp, y : VectorBitwiseOp) -> Bool

VectorBitwiseOp::to_repr

source

fn VectorBitwiseOp::to_repr(VectorBitwiseOp) -> @moonbitlang/core/debug.Repr
Repr

VectorConversionOp

source

pub(all) enum VectorConversionOp {
  ExtendLow(VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  ExtendHigh(VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  Narrow(VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  FloatToInt(VectorLane, VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness, @Milky2018/vcode/native_types.ConversionMode
ConversionMode)
  IntToFloat(VectorLane, VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  PromoteLowF32x4
  DemoteZeroF64x2
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorConversionOp::equal

source

fn VectorConversionOp::equal(VectorConversionOp, VectorConversionOp) -> Bool

VectorConversionOp::hash

source

fn VectorConversionOp::hash(self : VectorConversionOp) -> Int

VectorConversionOp::hash_combine

source

fn VectorConversionOp::hash_combine(VectorConversionOp, Hasher) -> Unit

VectorConversionOp::not_equal

source

fn VectorConversionOp::not_equal(x : VectorConversionOp, y : VectorConversionOp) -> Bool

VectorConversionOp::to_repr

source

fn VectorConversionOp::to_repr(VectorConversionOp) -> @moonbitlang/core/debug.Repr
Repr

VectorFloatBinaryOp

source

pub(all) enum VectorFloatBinaryOp {
  Add
  Sub
  Mul
  Div
  Min
  Max
  PseudoMin
  PseudoMax
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorFloatBinaryOp::equal

source

fn VectorFloatBinaryOp::equal(VectorFloatBinaryOp, VectorFloatBinaryOp) -> Bool

VectorFloatBinaryOp::hash

source

fn VectorFloatBinaryOp::hash(self : VectorFloatBinaryOp) -> Int

VectorFloatBinaryOp::hash_combine

source

fn VectorFloatBinaryOp::hash_combine(VectorFloatBinaryOp, Hasher) -> Unit

VectorFloatBinaryOp::not_equal

source

fn VectorFloatBinaryOp::not_equal(x : VectorFloatBinaryOp, y : VectorFloatBinaryOp) -> Bool

VectorFloatBinaryOp::to_repr

source

fn VectorFloatBinaryOp::to_repr(VectorFloatBinaryOp) -> @moonbitlang/core/debug.Repr
Repr

VectorFloatComparison

source

pub(all) enum VectorFloatComparison {
  Equal
  NotEqual
  LessThan
  LessOrEqual
  GreaterThan
  GreaterOrEqual
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorFloatComparison::equal

source

fn VectorFloatComparison::equal(VectorFloatComparison, VectorFloatComparison) -> Bool

VectorFloatComparison::hash

source

fn VectorFloatComparison::hash(self : VectorFloatComparison) -> Int

VectorFloatComparison::hash_combine

source

fn VectorFloatComparison::hash_combine(VectorFloatComparison, Hasher) -> Unit

VectorFloatComparison::not_equal

source

fn VectorFloatComparison::not_equal(x : VectorFloatComparison, y : VectorFloatComparison) -> Bool

VectorFloatComparison::to_repr

source

fn VectorFloatComparison::to_repr(VectorFloatComparison) -> @moonbitlang/core/debug.Repr
Repr

VectorFloatUnaryOp

source

pub(all) enum VectorFloatUnaryOp {
  Absolute
  Negate
  SquareRoot
  Ceil
  Floor
  Truncate
  Nearest
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorFloatUnaryOp::equal

source

fn VectorFloatUnaryOp::equal(VectorFloatUnaryOp, VectorFloatUnaryOp) -> Bool

VectorFloatUnaryOp::hash

source

fn VectorFloatUnaryOp::hash(self : VectorFloatUnaryOp) -> Int

VectorFloatUnaryOp::hash_combine

source

fn VectorFloatUnaryOp::hash_combine(VectorFloatUnaryOp, Hasher) -> Unit

VectorFloatUnaryOp::not_equal

source

fn VectorFloatUnaryOp::not_equal(x : VectorFloatUnaryOp, y : VectorFloatUnaryOp) -> Bool

VectorFloatUnaryOp::to_repr

source

fn VectorFloatUnaryOp::to_repr(VectorFloatUnaryOp) -> @moonbitlang/core/debug.Repr
Repr

VectorHalf

source

pub(all) enum VectorHalf {
  Low
  High
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorHalf::equal

source

fn VectorHalf::equal(VectorHalf, VectorHalf) -> Bool

VectorHalf::hash

source

fn VectorHalf::hash(self : VectorHalf) -> Int

VectorHalf::hash_combine

source

fn VectorHalf::hash_combine(VectorHalf, Hasher) -> Unit

VectorHalf::not_equal

source

fn VectorHalf::not_equal(x : VectorHalf, y : VectorHalf) -> Bool

VectorHalf::to_repr

source

fn VectorHalf::to_repr(VectorHalf) -> @moonbitlang/core/debug.Repr
Repr

VectorIntBinaryOp

source

pub(all) enum VectorIntBinaryOp {
  Add
  Sub
  Mul
  Min(@Milky2018/vcode/native_types.Signedness
Signedness)
  Max(@Milky2018/vcode/native_types.Signedness
Signedness)
  AverageUnsigned
  SaturatingAdd(@Milky2018/vcode/native_types.Signedness
Signedness)
  SaturatingSub(@Milky2018/vcode/native_types.Signedness
Signedness)
  ExtendMultiply(VectorHalf, @Milky2018/vcode/native_types.Signedness
Signedness)
  Dot16To32Signed
  Q15MultiplyRoundedSaturating
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorIntBinaryOp::equal

source

fn VectorIntBinaryOp::equal(VectorIntBinaryOp, VectorIntBinaryOp) -> Bool

VectorIntBinaryOp::hash

source

fn VectorIntBinaryOp::hash(self : VectorIntBinaryOp) -> Int

VectorIntBinaryOp::hash_combine

source

fn VectorIntBinaryOp::hash_combine(VectorIntBinaryOp, Hasher) -> Unit

VectorIntBinaryOp::not_equal

source

fn VectorIntBinaryOp::not_equal(x : VectorIntBinaryOp, y : VectorIntBinaryOp) -> Bool

VectorIntBinaryOp::to_repr

source

fn VectorIntBinaryOp::to_repr(VectorIntBinaryOp) -> @moonbitlang/core/debug.Repr
Repr

VectorIntComparison

source

pub(all) enum VectorIntComparison {
  Equal
  NotEqual
  LessThan(@Milky2018/vcode/native_types.Signedness
Signedness)
  LessOrEqual(@Milky2018/vcode/native_types.Signedness
Signedness)
  GreaterThan(@Milky2018/vcode/native_types.Signedness
Signedness)
  GreaterOrEqual(@Milky2018/vcode/native_types.Signedness
Signedness)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorIntComparison::equal

source

fn VectorIntComparison::equal(VectorIntComparison, VectorIntComparison) -> Bool

VectorIntComparison::hash

source

fn VectorIntComparison::hash(self : VectorIntComparison) -> Int

VectorIntComparison::hash_combine

source

fn VectorIntComparison::hash_combine(VectorIntComparison, Hasher) -> Unit

VectorIntComparison::not_equal

source

fn VectorIntComparison::not_equal(x : VectorIntComparison, y : VectorIntComparison) -> Bool

VectorIntComparison::to_repr

source

fn VectorIntComparison::to_repr(VectorIntComparison) -> @moonbitlang/core/debug.Repr
Repr

VectorIntShiftOp

source

pub(all) enum VectorIntShiftOp {
  Left
  Right(@Milky2018/vcode/native_types.Signedness
Signedness)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorIntShiftOp::equal

source

fn VectorIntShiftOp::equal(VectorIntShiftOp, VectorIntShiftOp) -> Bool

VectorIntShiftOp::hash

source

fn VectorIntShiftOp::hash(self : VectorIntShiftOp) -> Int

VectorIntShiftOp::hash_combine

source

fn VectorIntShiftOp::hash_combine(VectorIntShiftOp, Hasher) -> Unit

VectorIntShiftOp::not_equal

source

fn VectorIntShiftOp::not_equal(x : VectorIntShiftOp, y : VectorIntShiftOp) -> Bool

VectorIntShiftOp::to_repr

source

fn VectorIntShiftOp::to_repr(VectorIntShiftOp) -> @moonbitlang/core/debug.Repr
Repr

VectorIntUnaryOp

source

pub(all) enum VectorIntUnaryOp {
  Absolute
  Negate
  PopulationCount
  ExtendAddPairwise(@Milky2018/vcode/native_types.Signedness
Signedness)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorIntUnaryOp::equal

source

fn VectorIntUnaryOp::equal(VectorIntUnaryOp, VectorIntUnaryOp) -> Bool

VectorIntUnaryOp::hash

source

fn VectorIntUnaryOp::hash(self : VectorIntUnaryOp) -> Int

VectorIntUnaryOp::hash_combine

source

fn VectorIntUnaryOp::hash_combine(VectorIntUnaryOp, Hasher) -> Unit

VectorIntUnaryOp::not_equal

source

fn VectorIntUnaryOp::not_equal(x : VectorIntUnaryOp, y : VectorIntUnaryOp) -> Bool

VectorIntUnaryOp::to_repr

source

fn VectorIntUnaryOp::to_repr(VectorIntUnaryOp) -> @moonbitlang/core/debug.Repr
Repr

VectorLane

source

pub(all) enum VectorLane {
  I8x16
  I16x8
  I32x4
  I64x2
  F32x4
  F64x2
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorLane::equal

source

fn VectorLane::equal(VectorLane, VectorLane) -> Bool

VectorLane::hash

source

fn VectorLane::hash(self : VectorLane) -> Int

VectorLane::hash_combine

source

fn VectorLane::hash_combine(VectorLane, Hasher) -> Unit

VectorLane::not_equal

source

fn VectorLane::not_equal(x : VectorLane, y : VectorLane) -> Bool

VectorLane::to_repr

source

fn VectorLane::to_repr(VectorLane) -> @moonbitlang/core/debug.Repr
Repr

VectorLoadKind

source

pub(all) enum VectorLoadKind {
  Splat(VectorLane)
  Extend(VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  Zero(@Milky2018/vcode/native_types.AccessWidth
AccessWidth)
  Lane(VectorLane, Int)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorLoadKind::equal

source

fn VectorLoadKind::equal(VectorLoadKind, VectorLoadKind) -> Bool

VectorLoadKind::hash

source

fn VectorLoadKind::hash(self : VectorLoadKind) -> Int

VectorLoadKind::hash_combine

source

fn VectorLoadKind::hash_combine(VectorLoadKind, Hasher) -> Unit

VectorLoadKind::not_equal

source

fn VectorLoadKind::not_equal(x : VectorLoadKind, y : VectorLoadKind) -> Bool

VectorLoadKind::to_repr

source

fn VectorLoadKind::to_repr(VectorLoadKind) -> @moonbitlang/core/debug.Repr
Repr

VectorLoadSpec

source

pub struct VectorLoadSpec {
  kind : VectorLoadKind
  offset : UInt64
  endianness : @Milky2018/vcode/native_types.Endianness
Endianness
  trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorLoadSpec::equal

source

fn VectorLoadSpec::equal(VectorLoadSpec, VectorLoadSpec) -> Bool

VectorLoadSpec::hash

source

fn VectorLoadSpec::hash(self : VectorLoadSpec) -> Int

VectorLoadSpec::hash_combine

source

fn VectorLoadSpec::hash_combine(VectorLoadSpec, Hasher) -> Unit

VectorLoadSpec::new

source

fn VectorLoadSpec::new(kind : VectorLoadKind, offset : UInt64, endianness : @Milky2018/vcode/native_types.Endianness
Endianness, trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?) -> VectorLoadSpec

VectorLoadSpec::not_equal

source

fn VectorLoadSpec::not_equal(x : VectorLoadSpec, y : VectorLoadSpec) -> Bool

VectorLoadSpec::to_repr

source

fn VectorLoadSpec::to_repr(VectorLoadSpec) -> @moonbitlang/core/debug.Repr
Repr

VectorOp

source

pub(all) enum VectorOp {
  Splat(VectorLane)
  ExtractLane(VectorLane, Int, @Milky2018/vcode/native_types.Signedness
Signedness?)
  ReplaceLane(VectorLane, Int)
  Shuffle(FixedArray[Int])
  Swizzle
  Bitwise(VectorBitwiseOp)
  IntUnary(VectorLane, VectorIntUnaryOp)
  IntBinary(VectorLane, VectorIntBinaryOp)
  IntShift(VectorLane, VectorIntShiftOp)
  IntCompare(VectorLane, VectorIntComparison)
  FloatUnary(VectorLane, VectorFloatUnaryOp)
  FloatBinary(VectorLane, VectorFloatBinaryOp)
  FloatTernary(VectorLane, FloatTernaryOp)
  FloatCompare(VectorLane, VectorFloatComparison)
  Predicate(VectorPredicateOp)
  Convert(VectorConversionOp)
  Relaxed(VectorRelaxedOp)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

VectorOp::equal

source

fn VectorOp::equal(VectorOp, VectorOp) -> Bool

VectorOp::not_equal

source

fn VectorOp::not_equal(x : VectorOp, y : VectorOp) -> Bool

VectorOp::to_repr

source

fn VectorOp::to_repr(VectorOp) -> @moonbitlang/core/debug.Repr
Repr

VectorPredicateOp

source

pub(all) enum VectorPredicateOp {
  AnyTrue
  AllTrue(VectorLane)
  BitMask(VectorLane)
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorPredicateOp::equal

source

fn VectorPredicateOp::equal(VectorPredicateOp, VectorPredicateOp) -> Bool

VectorPredicateOp::hash

source

fn VectorPredicateOp::hash(self : VectorPredicateOp) -> Int

VectorPredicateOp::hash_combine

source

fn VectorPredicateOp::hash_combine(VectorPredicateOp, Hasher) -> Unit

VectorPredicateOp::not_equal

source

fn VectorPredicateOp::not_equal(x : VectorPredicateOp, y : VectorPredicateOp) -> Bool

VectorPredicateOp::to_repr

source

fn VectorPredicateOp::to_repr(VectorPredicateOp) -> @moonbitlang/core/debug.Repr
Repr

VectorRelaxedOp

source

pub(all) enum VectorRelaxedOp {
  Swizzle
  FloatToInt(VectorLane, VectorLane, @Milky2018/vcode/native_types.Signedness
Signedness)
  FusedMultiplyAdd(VectorLane, FloatTernaryOp)
  LaneSelect(VectorLane)
  Min(VectorLane)
  Max(VectorLane)
  Q15MultiplyRoundedSigned
  Dot8To16Signed
  Dot8To32AddSigned
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorRelaxedOp::equal

source

fn VectorRelaxedOp::equal(VectorRelaxedOp, VectorRelaxedOp) -> Bool

VectorRelaxedOp::hash

source

fn VectorRelaxedOp::hash(self : VectorRelaxedOp) -> Int

VectorRelaxedOp::hash_combine

source

fn VectorRelaxedOp::hash_combine(VectorRelaxedOp, Hasher) -> Unit

VectorRelaxedOp::not_equal

source

fn VectorRelaxedOp::not_equal(x : VectorRelaxedOp, y : VectorRelaxedOp) -> Bool

VectorRelaxedOp::to_repr

source

fn VectorRelaxedOp::to_repr(VectorRelaxedOp) -> @moonbitlang/core/debug.Repr
Repr

VectorStoreLaneSpec

source

pub struct VectorStoreLaneSpec {
  lane : VectorLane
  lane_index : Int
  offset : UInt64
  endianness : @Milky2018/vcode/native_types.Endianness
Endianness
  trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?
} derive(Eq, Hash, @moonbitlang/core/debug.Debug
Debug)

VectorStoreLaneSpec::equal

source

fn VectorStoreLaneSpec::equal(VectorStoreLaneSpec, VectorStoreLaneSpec) -> Bool

VectorStoreLaneSpec::hash

source

fn VectorStoreLaneSpec::hash(self : VectorStoreLaneSpec) -> Int

VectorStoreLaneSpec::hash_combine

source

fn VectorStoreLaneSpec::hash_combine(VectorStoreLaneSpec, Hasher) -> Unit

VectorStoreLaneSpec::new

source

fn VectorStoreLaneSpec::new(lane : VectorLane, lane_index : Int, offset : UInt64, endianness : @Milky2018/vcode/native_types.Endianness
Endianness, trap : @Milky2018/vcode/native_types.TrapReason
TrapReason?) -> VectorStoreLaneSpec

VectorStoreLaneSpec::not_equal

source

fn VectorStoreLaneSpec::not_equal(x : VectorStoreLaneSpec, y : VectorStoreLaneSpec) -> Bool

VectorStoreLaneSpec::to_repr

source

fn VectorStoreLaneSpec::to_repr(VectorStoreLaneSpec) -> @moonbitlang/core/debug.Repr
Repr

verify_call_operands

source

fn verify_call_operands(call : @Milky2018/vcode/native_types.NativeCall
NativeCall, operands : Array[@Milky2018/vcode/native_types.ValueType
ValueType], context : String) -> String?

verify_operation_contract

source

fn verify_operation_contract(op : Operation, operands : Array[@Milky2018/vcode/native_types.ValueType
ValueType], results : Array[@Milky2018/vcode/native_types.ValueType
ValueType]) -> String?

Source Files

Site source Report issue Packages Build queue Skills Statistics

#DirectLoweringError

#DirectLoweringError::equal

#DirectLoweringError::not_equal

#DirectLoweringError::output

#DirectLoweringError::to_repr

#DirectLoweringError::to_string

#AtomicRmwOp

#AtomicRmwOp::equal

#AtomicRmwOp::hash

#AtomicRmwOp::hash_combine

#AtomicRmwOp::not_equal

#AtomicRmwOp::to_repr

#AtomicSpec

#AtomicSpec::equal

#AtomicSpec::hash

#AtomicSpec::hash_combine

#AtomicSpec::new

#AtomicSpec::not_equal

#AtomicSpec::to_repr

#Block

#Block::equal

#Block::hash

#Block::hash_combine

#Block::not_equal

#Block::to_repr

#CallAbiElaboration

#CallAbiElaboration::new

#CallerRootScopeAbi

#CallerRootScopeAbi::new

#ConversionOp

#ConversionOp::equal

#ConversionOp::hash

#ConversionOp::hash_combine

#ConversionOp::not_equal

#ConversionOp::to_repr

#DirectBuilder

#DirectBuilder::block_parameters

#DirectBuilder::branch

#DirectBuilder::branch_int_compare

#DirectBuilder::branch_int_compare_immediate

#DirectBuilder::create_block

#DirectBuilder::create_stack_object

#DirectBuilder::emit_with_metadata

#DirectBuilder::entry_block

#DirectBuilder::finish

#DirectBuilder::jump

#DirectBuilder::new

#DirectBuilder::noreturn_call_with_metadata

#DirectBuilder::parameters

#DirectBuilder::return_

#DirectBuilder::set_terminator_source

#DirectBuilder::switch

#DirectBuilder::switch_to_block

#DirectBuilder::tail_call_with_metadata

#DirectBuilder::trap

#DirectBuilder::value_type

#FloatBinaryOp

#FloatBinaryOp::equal

#FloatBinaryOp::hash

#FloatBinaryOp::hash_combine

#FloatBinaryOp::not_equal

#FloatBinaryOp::to_repr

#FloatComparison

#FloatComparison::equal

#FloatComparison::hash

#FloatComparison::hash_combine

#FloatComparison::not_equal

#FloatComparison::to_repr

#FloatTernaryOp

#FloatTernaryOp::equal

#FloatTernaryOp::hash

#FloatTernaryOp::hash_combine

#FloatTernaryOp::not_equal

#FloatTernaryOp::to_repr

#FloatUnaryOp

#FloatUnaryOp::equal

#FloatUnaryOp::hash

#FloatUnaryOp::hash_combine

#FloatUnaryOp::not_equal

#FloatUnaryOp::to_repr

DirectLoweringError

DirectLoweringError::equal

DirectLoweringError::not_equal

DirectLoweringError::output

DirectLoweringError::to_repr

DirectLoweringError::to_string

AtomicRmwOp

AtomicRmwOp::equal

AtomicRmwOp::hash

AtomicRmwOp::hash_combine

AtomicRmwOp::not_equal

AtomicRmwOp::to_repr

AtomicSpec

AtomicSpec::equal

AtomicSpec::hash

AtomicSpec::hash_combine

AtomicSpec::new

AtomicSpec::not_equal

AtomicSpec::to_repr

Block

Block::equal

Block::hash

Block::hash_combine

Block::not_equal

Block::to_repr

CallAbiElaboration

CallAbiElaboration::new

CallerRootScopeAbi

CallerRootScopeAbi::new

ConversionOp

ConversionOp::equal

ConversionOp::hash

ConversionOp::hash_combine

ConversionOp::not_equal

ConversionOp::to_repr

DirectBuilder

DirectBuilder::block_parameters

DirectBuilder::branch

DirectBuilder::branch_int_compare

DirectBuilder::branch_int_compare_immediate

DirectBuilder::create_block

DirectBuilder::create_stack_object

DirectBuilder::emit_with_metadata

DirectBuilder::entry_block

DirectBuilder::finish

DirectBuilder::jump

DirectBuilder::new

DirectBuilder::noreturn_call_with_metadata

DirectBuilder::parameters

DirectBuilder::return_

DirectBuilder::set_terminator_source

DirectBuilder::switch

DirectBuilder::switch_to_block

DirectBuilder::tail_call_with_metadata

DirectBuilder::trap

DirectBuilder::value_type

FloatBinaryOp

FloatBinaryOp::equal

FloatBinaryOp::hash

FloatBinaryOp::hash_combine

FloatBinaryOp::not_equal

FloatBinaryOp::to_repr

FloatComparison

FloatComparison::equal

FloatComparison::hash

FloatComparison::hash_combine

FloatComparison::not_equal

FloatComparison::to_repr

FloatTernaryOp

FloatTernaryOp::equal

FloatTernaryOp::hash

FloatTernaryOp::hash_combine

FloatTernaryOp::not_equal

FloatTernaryOp::to_repr

FloatUnaryOp

FloatUnaryOp::equal

FloatUnaryOp::hash

FloatUnaryOp::hash_combine

FloatUnaryOp::not_equal

FloatUnaryOp::to_repr