🥮 mooncakes.io

    x64_target

    x64 direct MilkIR target pipeline to native code

    x64
    x86-64
    compiler
    codegen
    Download zip
    Author
    Version
    0.19.0
    License
    Apache-2.0
    Repository
    Last updated
    3 days ago
    Downloads
    1K

    #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" {
      @x64_target.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.

    Frame planning includes writes made by late parallel transfers to the reserved R15 temporary. The same call transfer planner is used for emission and this register footprint; a function saves R15 only when its emitted transfers need it.

    GprWidth

    source
    using @Milky2018/vcode { type RegisterWidth as GprWidth }

    InternalAbi

    source

    Register assignment shared by the native backends' internal calls.

    InternalAbiError

    source

    InternalCallPlan

    source

    LoweringContext

    source

    TargetVCodeVerifyError

    source

    X64Address

    source
    using @Milky2018/vcode { type SymbolicAddress as X64Address }

    X64Condition

    source
    using @Milky2018/vcode { type IntegerCondition as X64Condition }

    X64FloatBinary

    source
    using @Milky2018/vcode/native_lowering { type FloatBinaryOp as X64FloatBinary }

    X64FloatCondition

    source
    using @Milky2018/vcode/native_lowering { type FloatComparison as X64FloatCondition }

    X64FloatTernary

    source
    using @Milky2018/vcode/native_lowering { type FloatTernaryOp as X64FloatTernary }

    X64FloatTrapCondition

    source
    using @Milky2018/vcode { type FloatTrapCondition as X64FloatTrapCondition }

    X64FloatUnary

    source
    using @Milky2018/vcode/native_lowering { type FloatUnaryOp as X64FloatUnary }

    X64IntUnary

    source
    using @Milky2018/vcode { type ScalarIntUnary as X64IntUnary }

    X64StackObject

    source
    using @Milky2018/vcode { type SizedStackObject as X64StackObject }

    A function-local stack object before target frame placement.

    X64VectorConversion

    source
    using @Milky2018/vcode { type VectorConversion as X64VectorConversion }

    X64VectorIntBinary

    source
    using @Milky2018/vcode/native_lowering { type VectorIntBinaryOp as X64VectorIntBinary }

    X64VectorIntUnary

    source
    using @Milky2018/vcode/native_lowering { type VectorIntUnaryOp as X64VectorIntUnary }

    X64VectorPredicate

    source
    using @Milky2018/vcode/native_lowering { type VectorPredicateOp as X64VectorPredicate }

    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    )
      CallPlanningFailed(cause~ : 
    CallTransferError    )
      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

    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
    fn CompilationSession::compile_selected(self : CompilationSession, selected : SelectedFunction, on_event? : (
    TargetCompileEvent    ) -> Unit, verify_allocation? : Bool, on_diagnostics? : (String, String) -> Unit?) -> (
    UnlinkedCodeObject    , Int) raise X64CompileError

    Compile selected VCode while retaining allocator scratch capacity for the next serial call on this session. Diagnostic strings are rendered only when on_diagnostics is supplied; the callback observes this same compilation.

    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

    SelectedFunction

    source
    pub struct SelectedFunction {
      // private fields
    }

    Opaque evidence that direct x64 selection and VCode validation completed.

    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

    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 : 
    SizedStackObject    ) -> 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(
    RegisterWidth    , UInt64)
      LoadVectorConstant(UInt64, UInt64)
      LoadNull(
    ValueType    )
      LoadAddress(
    SymbolicAddress    )
      StackAddress(
    SizedStackObject    )
      LoadFloatConstant(
    ValueType    , UInt64)
      Move(
    ValueType    )
      CarrierMove(
    ValueType    , 
    ValueType    )
      Select(
    ValueType    )
      SpectreGuard
      VectorSelect
      VectorSplat(
    VectorLane    )
      VectorExtractLane(
    VectorLane    , Int, 
    Signedness    ?)
      VectorReplaceLane(
    VectorLane    , Int)
      VectorShuffle(FixedArray[Int])
      VectorSwizzle
      VectorBitwise(
    VectorBitwiseOp    )
      VectorIntUnary(
    VectorLane    , 
    VectorIntUnaryOp    )
      VectorIntBinary(
    VectorLane    , 
    VectorIntBinaryOp    )
      VectorIntShift(
    VectorLane    , 
    VectorIntShiftOp    )
      VectorIntCompare(
    VectorLane    , 
    VectorIntComparison    )
      VectorConvert(
    VectorConversion    )
      VectorPredicate(
    VectorPredicateOp    )
      VectorFloatUnary(
    VectorLane    , 
    VectorFloatUnaryOp    )
      VectorFloatBinary(
    VectorLane    , 
    VectorFloatBinaryOp    )
      VectorFloatTernary(
    VectorLane    , 
    FloatTernaryOp    )
      VectorFloatCompare(
    VectorLane    , 
    VectorFloatComparison    )
      VectorPairwiseAddI16x8
      VectorRelaxedDot8To16
      IntUnary(
    RegisterWidth    , 
    ScalarIntUnary    )
      IntBinary(
    RegisterWidth    , X64IntBinary)
      PopulationCount(
    RegisterWidth    )
      IntHighMultiply(
    RegisterWidth    , 
    Signedness    )
      IntWithOverflow(
    RegisterWidth    , 
    IntOverflowOp    )
      IntRemainder(
    RegisterWidth    , 
    Signedness    )
      TrapIfZero(
    RegisterWidth    )
      TrapIfSignedDivOverflow(
    RegisterWidth    )
      CompareSet(
    RegisterWidth    , 
    IntegerCondition    )
      ReferenceCompareSet(
    ValueType    , 
    IntegerCondition    )
      FloatUnary(
    ValueType    , 
    FloatUnaryOp    )
      FloatBinary(
    ValueType    , 
    FloatBinaryOp    )
      FloatTernary(
    ValueType    , 
    FloatTernaryOp    )
      FloatCompareSet(
    ValueType    , 
    FloatComparison    )
      TrapIfFloat(
    ValueType    , 
    FloatTrapCondition    )
      Convert(X64Conversion)
      AddAddress
      ScalarLoad(
    AccessWidth    , 
    LoadExtension    , 
    ValueType    , UInt64)
      ScalarStore(
    AccessWidth    , 
    ValueType    , UInt64)
      StoreRepeated64(UInt64, UInt, 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
      BranchCompare(
    RegisterWidth    , 
    IntegerCondition    )
      Switch(
    RegisterWidth    , 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

    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]

    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

    Source Files