🥮 mooncakes.io

x64_target

x64 direct MilkIR target pipeline to native code

x64
x86-64
compiler
codegen
Download zip
Author
Version
0.14.0
License
Apache-2.0
Repository
Last updated
16 hours ago
Downloads
126

Dependencies

#x64_target

x64 backend for direct MilkIR instruction selection.

This module owns x64 instruction selection, validation and lowering of an embedding-provided internal ABI contract, register allocation policy, frame layout, machine-code emission, relocations, and final linking. A DirectLoweringSession consumes the streaming native-lowering protocol and constructs verified x64 Target VCode without an intermediate function graph.

#Package

  • Milky2018/x64_target: x64 Target VCode, lowering, allocation, frame layout, emission, and linking.

#When to use it

Use this module as the target sink for Milky2018/milkir/native, then install its generated code object through the embedding runtime.

#Example: define the internal ABI

///|
test "validate the x64 internal ABI" {
  InternalAbi::new(7, 10, [6, 2, 1, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7], [0, 2], [
    0, 1,
  ])
  |> ignore
}

#Integration

Finish a DirectLoweringSession, then use compile_selected for the aggregate path, or call allocate, plan_frame, and emit when inspecting checkpoints. The returned UnlinkedCodeObject contains bytes, relocations, and safepoints; the embedding application supplies symbol addresses and executable memory.

compile accepts an optional on_event callback that reports generic stage boundaries and a read-only allocation summary. This lets an embedding collect metrics without coupling the target to a product metrics system. The callback must not mutate compiler inputs.

Parallel moves use R15 and XMM13 as dedicated transfer scratches and share the target-neutral emergency-aware move planner with AArch64. R10 and XMM14 remain the allocator's spill/edit scratches; R11 is a declared fixed-operand-only instruction temporary, and XMM15 remains reserved for emitter-local expansion. The frame reserves a raw 16-byte emergency area only for move groups that require it.

InternalAbiError

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

InternalAbiError::equal

source

InternalAbiError::not_equal

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

InternalAbiError::output

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

InternalAbiError::to_repr

source

InternalAbiError::to_string

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

TargetVCodeVerifyError

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

TargetVCodeVerifyError::equal

source

TargetVCodeVerifyError::not_equal

source

TargetVCodeVerifyError::output

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

TargetVCodeVerifyError::to_repr

source

TargetVCodeVerifyError::to_string

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

X64AllocationError

source

X64AllocationError::output

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

X64AllocationError::to_repr

source

X64AllocationError::to_string

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

X64CompileError

source
pub suberror X64CompileError {
  TargetValidationFailed(cause~ : TargetVCodeVerifyError)
  AllocationFailed(cause~ : X64AllocationError)
  FramePlanningFailed(cause~ : X64FrameError)
  EmissionFailed(cause~ : X64EmitError)
} derive(
Debug)

X64CompileError::output

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

X64CompileError::to_repr

source

X64CompileError::to_string

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

X64EmitError

source
pub suberror X64EmitError {
  InvalidFrame(cause~ : X64FrameError)
  InvalidCodeObject(cause~ : 
CodeObjectVerifyError)
  InvalidParallelMove(cause~ : 
MoveResolveError)
  InvalidCallTransfer(cause~ : 
CallTransferError)
  UnresolvedStackMove
  MissingStackObjectArea
  MissingResultArea
  MissingEmergencyMoveArea
  UnexpectedStackOperand(instruction~ : 
Instruction, operand~ : Int)
  FrameOffsetOutOfRange(offset~ : Int)
  InvalidScalarMemoryAccess
  InvalidFloatInstruction
  InvalidVectorInstruction
  ScratchRegisterUnavailable
  InvalidConversionInstruction
  BranchTargetMissing(block~ : 
Block)
  BranchOutOfRange(offset~ : Int, bits~ : Int)
} derive(
Debug)

X64EmitError::output

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

X64EmitError::to_repr

source

X64EmitError::to_string

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

X64FrameError

source
pub suberror X64FrameError {
  InvalidAllocation(cause~ : X64AllocationError)
  InvalidGenericFrame(cause~ : 
FrameVerifyError)
  InvalidSavedRegister(reg~ : 
PhysicalReg, offset~ : Int)
  InvalidStackSlot(slot~ : 
StackSlot)
  OutgoingAreaMismatch(expected~ : Int, actual~ : Int)
  ResultAreaMismatch(expected~ : Int, actual~ : Int)
  TailAreaMismatch(expected_incoming~ : Int, actual_incoming~ : Int, expected_tail~ : Int, actual_tail~ : Int)
  InvalidStackObjectArea(message~ : String)
  MovePlanningFailed(cause~ : 
MoveResolveError)
  InvalidEmergencyMoveArea(offset~ : Int?)
  StaleAllocation(expected_edits~ : Int, actual_edits~ : Int)
  SavedRegisterSetMismatch
} derive(
Debug)

X64FrameError::output

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

X64FrameError::to_repr

source

X64FrameError::to_string

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

X64LinkError

source
pub suberror X64LinkError {
  InvalidCodeObject(message~ : String)
  InvalidCodeBase(address~ : Int64)
  UnresolvedRelocation(index~ : Int)
  RelocationOutOfRange(index~ : Int)
  UnsupportedRelocation(index~ : Int)
} derive(Eq, 
Debug)

X64LinkError::equal

source

X64LinkError::not_equal

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

X64LinkError::output

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

X64LinkError::to_repr

source

X64LinkError::to_string

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

X64LowerError

source
pub suberror X64LowerError {
  UnsupportedOperation(block_index~ : Int, instruction_index~ : Int, operation~ : 
Operation)
  UnsupportedAbi(message~ : String)
  BuildFailure(cause~ : 
VCodeBuildError)
  InvalidTarget(cause~ : TargetVCodeVerifyError)
} derive(
Debug)

X64LowerError::output

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

X64LowerError::to_repr

source

X64LowerError::to_string

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

CallArgumentLocation

source
type CallArgumentLocation derive(Eq, 
Debug)

CallArgumentLocation::equal

source

CallArgumentLocation::not_equal

source

CallArgumentLocation::to_repr

source

CallLayout

source
type CallLayout derive(Eq, 
Debug)

CallLayout::equal

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

CallLayout::not_equal

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

CallLayout::to_repr

source

CallResultLocation

source
type CallResultLocation derive(Eq, 
Debug)

CallResultLocation::equal

source

CallResultLocation::not_equal

source

CallResultLocation::to_repr

source

CompilationDiagnostics

source
pub(all) struct CompilationDiagnostics {
  target_vcode : String
  allocated_vcode : String
  object : 
UnlinkedCodeObject
}

CompilationSession

source
pub struct CompilationSession {
  // private fields
}

Compiles selected x64 VCode through allocation, frame planning, and emission. Each stage validates the invariant it introduces without revalidating invariants already established by this pipeline.

on_event is an observation-only seam. It must not mutate function or any compiler object reachable while the callback runs.

CompilationSession::compile_selected

source

Compile selected VCode while retaining allocator scratch capacity for the next serial call on this session.

CompilationSession::new

source

DirectLoweringSession

source
pub struct DirectLoweringSession {
  // private fields
}

DirectLoweringSession::finish_selected

source
fn DirectLoweringSession::finish_selected(self : DirectLoweringSession, verify_selected? : Bool) -> SelectedFunction raise X64LowerError

Finish direct selection and return the VCode consumed by target compilation.

verify_selected=false is reserved for compiler-owned construction paths covered by strict validation in CI. Public callers should keep the default.

DirectLoweringSession::new

source

DirectLoweringSession::sink

source

GprWidth

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

GprWidth::equal

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

GprWidth::not_equal

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

GprWidth::to_repr

source

InternalAbi

source
pub struct InternalAbi {
  // private fields
}

InternalAbi::new

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

InternalCallPlan

source
pub struct InternalCallPlan {
  // private fields
} derive(Eq, 
Debug)

InternalCallPlan::equal

source

InternalCallPlan::not_equal

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

InternalCallPlan::to_repr

source

LoweringContext

source
pub struct LoweringContext {
  // private fields
}

LoweringContext::new

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

LoweringContext::with_environment_field

source

LoweringContext::with_environment_field_resolver

source

SelectedFunction

source
pub struct SelectedFunction {
  // private fields
}

Opaque evidence that direct x64 selection and VCode validation completed.

X64Address

source

X64Address::equal

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

X64Address::not_equal

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

X64Address::to_repr

source

X64Condition

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

X64Condition::equal

source

X64Condition::not_equal

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

X64Condition::to_repr

source

X64Conversion

source
pub(all) enum X64Conversion {
  WrapI64ToI32
  ExtendI32ToI64(
Signedness)
  SignExtend(
IntegerType, 
AccessWidth)
  DemoteF64ToF32
  PromoteF32ToF64
  Bitcast(
ValueType, 
ValueType)
  IntToFloat(
IntegerType, 
FloatType, 
Signedness)
  FloatToInt(
FloatType, 
IntegerType, 
Signedness)
  FloatToIntSaturating(
FloatType, 
IntegerType, 
Signedness)
} derive(Eq, 
Debug)

X64Conversion::equal

source

X64Conversion::not_equal

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

X64Conversion::to_repr

source

X64FloatBinary

source
pub(all) enum X64FloatBinary {
  Add
  Sub
  Mul
  Div
  Min
  Max
  CopySign
} derive(Eq, 
Debug)

X64FloatBinary::equal

source

X64FloatBinary::not_equal

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

X64FloatBinary::to_repr

source

X64FloatCondition

source
pub(all) enum X64FloatCondition {
  Equal
  NotEqual
  LessThan
  LessOrEqual
  GreaterThan
  GreaterOrEqual
  Ordered
  Unordered
} derive(Eq, 
Debug)

X64FloatCondition::equal

source

X64FloatCondition::not_equal

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

X64FloatCondition::to_repr

source

X64FloatTernary

source
pub(all) enum X64FloatTernary {
  Fmadd
  Fmsub
  Fnmadd
  Fnmsub
} derive(Eq, 
Debug)

X64FloatTernary::equal

source

X64FloatTernary::not_equal

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

X64FloatTernary::to_repr

source

X64FloatTrapCondition

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

X64FloatTrapCondition::equal

source

X64FloatTrapCondition::not_equal

source

X64FloatTrapCondition::to_repr

source

X64FloatUnary

source
pub(all) enum X64FloatUnary {
  Negate
  Absolute
  SquareRoot
  Ceil
  Floor
  Truncate
  Nearest
} derive(Eq, 
Debug)

X64FloatUnary::equal

source

X64FloatUnary::not_equal

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

X64FloatUnary::to_repr

source

X64Frame

source
pub struct X64Frame {
  // private fields
}

X64Frame::alignment

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

X64Frame::emergency_move_offset

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

X64Frame::frame_size

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

X64Frame::incoming_args_size

source
fn X64Frame::incoming_args_size(self : X64Frame) -> Int

X64Frame::outgoing_args_size

source
fn X64Frame::outgoing_args_size(self : X64Frame) -> Int

X64Frame::saved_registers

source

X64Frame::slot_offset

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

X64Frame::stack_object_offset

source
fn X64Frame::stack_object_offset(self : X64Frame, object : X64StackObject) -> Int?

X64Frame::summary

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

X64Frame::tail_args_size

source
fn X64Frame::tail_args_size(self : X64Frame) -> Int

X64Inst

source
pub(all) enum X64Inst {
  IncomingReg(
ValueType, 
PhysicalReg)
  IncomingStack(
ValueType, Int)
  IncomingResultArea(
PhysicalReg)
  IncomingCallResult(
ValueType, 
PhysicalReg)
  IncomingCallAreaResult(
ValueType, Int)
  OutgoingReg(
ValueType, 
PhysicalReg)
  OutgoingAreaResult(
ValueType, Int)
  KeepAlive(
ValueType)
  LoadConstant(GprWidth, UInt64)
  LoadVectorConstant(UInt64, UInt64)
  LoadNull(
ValueType)
  LoadAddress(X64Address)
  StackAddress(X64StackObject)
  LoadFloatConstant(
ValueType, UInt64)
  Move(
ValueType)
  CarrierMove(
ValueType, 
ValueType)
  Select(
ValueType)
  VectorSelect
  VectorSplat(
VectorLane)
  VectorExtractLane(
VectorLane, Int, 
Signedness?)
  VectorReplaceLane(
VectorLane, Int)
  VectorShuffle(FixedArray[Int])
  VectorSwizzle
  VectorBitwise(
VectorBitwiseOp)
  VectorIntUnary(
VectorLane, X64VectorIntUnary)
  VectorIntBinary(
VectorLane, X64VectorIntBinary)
  VectorIntShift(
VectorLane, 
VectorIntShiftOp)
  VectorIntCompare(
VectorLane, 
VectorIntComparison)
  VectorConvert(X64VectorConversion)
  VectorPredicate(X64VectorPredicate)
  VectorFloatUnary(
VectorLane, 
VectorFloatUnaryOp)
  VectorFloatBinary(
VectorLane, 
VectorFloatBinaryOp)
  VectorFloatTernary(
VectorLane, 
FloatTernaryOp)
  VectorFloatCompare(
VectorLane, 
VectorFloatComparison)
  VectorPairwiseAddI16x8
  VectorRelaxedDot8To16
  IntUnary(GprWidth, X64IntUnary)
  IntBinary(GprWidth, X64IntBinary)
  PopulationCount(GprWidth)
  IntHighMultiply(GprWidth, 
Signedness)
  IntWithOverflow(GprWidth, 
IntOverflowOp)
  IntRemainder(GprWidth, 
Signedness)
  TrapIfZero(GprWidth)
  TrapIfSignedDivOverflow(GprWidth)
  CompareSet(GprWidth, X64Condition)
  ReferenceCompareSet(
ValueType, X64Condition)
  FloatUnary(
ValueType, X64FloatUnary)
  FloatBinary(
ValueType, X64FloatBinary)
  FloatTernary(
ValueType, X64FloatTernary)
  FloatCompareSet(
ValueType, X64FloatCondition)
  TrapIfFloat(
ValueType, X64FloatTrapCondition)
  Convert(X64Conversion)
  AddAddress
  ScalarLoad(
AccessWidth, 
LoadExtension, 
ValueType, UInt64)
  ScalarStore(
AccessWidth, 
ValueType, UInt64)
  VectorLoad128(UInt64)
  VectorStore128(UInt64)
  VectorLoadSplat(
VectorLane, UInt64)
  VectorLoadExtend(
VectorLane, 
Signedness, UInt64)
  VectorLoadZero(
AccessWidth, UInt64)
  VectorLoadLane(
VectorLane, Int, UInt64)
  VectorStoreLane(
VectorLane, Int, UInt64)
  AtomicLoad(
AccessWidth, 
ValueType)
  AtomicStore(
AccessWidth, 
ValueType)
  AtomicRmw(
AccessWidth, 
ValueType, 
AtomicRmwOp)
  AtomicCompareExchange(
AccessWidth, 
ValueType)
  AtomicFence
  SafepointMarker
  PlatformCall(
ExternalSymbol, 
Signature)
  ReturnsTwicePlatformCall(
ExternalSymbol, 
Signature)
  InternalCall(
CodeSymbol, 
Signature, InternalCallPlan)
  InternalCallIndirect(
Signature, InternalCallPlan)
  TailCallDirect(
CodeSymbol, 
Signature, InternalCallPlan)
  TailCallIndirect(
Signature, InternalCallPlan)
  Jump
  BranchNonZero32
  Switch(GprWidth, Array[UInt64])
  Trap(
TrapReason)
  Return
} derive(Eq, 
Debug)

X64Inst::equal

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

X64Inst::not_equal

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

X64Inst::to_repr

source

X64IntBinary

source
pub(all) enum X64IntBinary {
  Add
  Sub
  Mul
  And
  Orr
  Eor
  Lsl
  Asr
  Lsr
  Ror
  Sdiv
  Udiv
} derive(Eq, 
Debug)

X64IntBinary::equal

source

X64IntBinary::not_equal

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

X64IntBinary::to_repr

source

X64IntUnary

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

X64IntUnary::equal

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

X64IntUnary::not_equal

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

X64IntUnary::to_repr

source

X64LinkPlan

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

X64LinkPlan::code

source
fn X64LinkPlan::code(self : X64LinkPlan) -> Array[Byte]

fn X64LinkPlan::link(self : X64LinkPlan, code_address : Int64, resolve : (
RelocationTarget) -> Int64?) -> Array[Byte] raise X64LinkError

X64LinkPlan::to_repr

source

X64LinkPlan::veneer_offsets

source
fn X64LinkPlan::veneer_offsets(self : X64LinkPlan) -> Array[Int]

X64StackObject

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

X64StackObject::equal

source

X64StackObject::new

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

X64StackObject::not_equal

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

X64StackObject::to_repr

source

X64VectorConversion

source

X64VectorConversion::equal

source

X64VectorConversion::not_equal

source

X64VectorConversion::to_repr

source

X64VectorIntBinary

source

X64VectorIntBinary::equal

source

X64VectorIntBinary::not_equal

source

X64VectorIntBinary::to_repr

source

X64VectorIntUnary

source
pub(all) enum X64VectorIntUnary {
  Absolute
  Negate
  PopulationCount
  ExtendAddPairwise(
Signedness)
} derive(Eq, 
Debug)

X64VectorIntUnary::equal

source

X64VectorIntUnary::not_equal

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

X64VectorIntUnary::to_repr

source

X64VectorPredicate

source

X64VectorPredicate::equal

source

X64VectorPredicate::not_equal

source

X64VectorPredicate::to_repr

source

allocate

source

compile

source

Compile externally supplied x64 VCode through the safe validated entry.

compile_selected

source
fn compile_selected(selected : SelectedFunction, on_event? : (
TargetCompileEvent) -> Unit, verify_allocation? : Bool) -> (
UnlinkedCodeObject, Int) raise X64CompileError

Compile VCode produced by select without repeating target validation.

diagnose_selected

source
fn diagnose_selected(selected : SelectedFunction) -> CompilationDiagnostics raise X64CompileError

emit

source

plan_frame

source

verify_allocation

source
fn verify_allocation(function : 
Function[X64Inst], allocation : 
Allocation) -> Unit raise X64AllocationError

verify_frame

source
fn verify_frame(function : 
Function[X64Inst], allocation : 
Allocation, frame : X64Frame) -> Unit raise X64FrameError

verify_vcode

source
fn verify_vcode(function : 
Function[X64Inst]) -> Unit raise TargetVCodeVerifyError

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io