🥮 mooncakes.io

x64_target

x64 target pipeline from semantic MachV to native code

x64
x86-64
compiler
codegen
moon add Milky2018/x64_target@0.5.2
Download zip
Author
Version
0.5.2
License
Apache-2.0
Repository
Last updated
2 days ago
Downloads
73

Dependencies

README

#x64_target

x64 backend for target-neutral MachV.

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. Verified MilkIR first becomes target-neutral MachV; this package then lowers that semantic function into x64 Target VCode.

#Package

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

#When to use it

Use this module after producing a verified Milky2018/machv.Function and before installing generated bytes into executable memory.

#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

Use lower followed by compile for the efficient aggregate path, or call allocate, plan_frame, and emit individually 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)

#
TargetVCodeVerifyError

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

#
X64AllocationError

source

#
X64CompileError

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

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

#
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?)
  SavedRegisterSetMismatch
} derive(
Debug)

#
X64LinkError

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

#
X64LowerError

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

#
CallArgumentLocation

source
type CallArgumentLocation derive(Eq, 
Debug)

#
CallLayout

source
type CallLayout derive(Eq, 
Debug)

#
CallResultLocation

source
type CallResultLocation derive(Eq, 
Debug)

#
GprWidth

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

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

#
LoweringContext

source
pub struct LoweringContext {
  // private fields
}

#
LoweringContext::new

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

#
LoweringContext::with_environment_field

source
fn LoweringContext::with_environment_field(self : LoweringContext, field : 
EnvironmentField, offsets : Array[Int]) -> LoweringContext

#
X64Address

source

#
X64Condition

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

#
X64Conversion

source

#
X64FloatBinary

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

#
X64FloatCondition

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

#
X64FloatTernary

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

#
X64FloatTrapCondition

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

#
X64FloatUnary

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

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

#
X64IntBinary

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

#
X64IntUnary

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

#
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::veneer_offsets

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

#
X64StackObject

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

#
X64StackObject::new

source
fn X64StackObject::new(offset : Int, size : Int, alignment : Int, area_size : Int, area_alignment : Int) -> X64StackObject

#
X64VectorConversion

source

#
X64VectorIntBinary

source
pub(all) enum X64VectorIntBinary {
  Add
  Sub
  Mul
  AverageUnsigned
  Min(
Signedness)
  Max(
Signedness)
  SaturatingAdd(
Signedness)
  SaturatingSub(
Signedness)
  ExtendMultiply(
VectorHalf, 
Signedness)
  Dot16To32Signed
  Q15MultiplyRoundedSaturating
} derive(Eq, 
Debug)

#
X64VectorIntUnary

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

#
X64VectorPredicate

source
pub(all) enum X64VectorPredicate {
  AnyTrue
  AllTrue(
VectorLane)
  BitMask(
VectorLane)
} derive(Eq, 
Debug)

#
allocate

source

#
compile

source

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.

#
emit

source

#
lower

source

#
plan_frame

source

#
verify_allocation

source

#
verify_frame

source

#
verify_vcode

source

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io