spill-rename-insn-defs ( insn -- )

Vocabulary

compiler.cfg.register-allocation.chordal.spilling

Inputs

insn

an object

Outputs

None

Definition

IN: compiler.cfg.register-allocation.chordal.spilling

GENERIC: spill-rename-insn-defs ( insn -- )

Methods

USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##abs-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##add-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##add-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##add-sub-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##add-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##add spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##alien-global spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##allot spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##and-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##and-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##and spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##andn-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##avg-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##binary-vector-function spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##bit-count spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##bit-test spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##blend-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##box-alien spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##box-displaced-alien spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##box-long-long spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##box spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors arrays assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces sequences ;

M: ##callback-inputs spill-rename-insn-defs
    [
        [
            first3
            [ dup spill-def-renaming get at swap or ] 2dip
            3array
        ] map
    ] change-reg-outputs [
        [
            first4
            [ dup spill-def-renaming get at swap or ] 3dip
            4array
        ] map
    ] change-stack-outputs drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##callback-stack spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-float-ordered spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-float-unordered spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-integer-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##compare spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##convert-integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##copy spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##div-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##div-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##dot-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##double>single-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##fill-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##fixnum-add spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##fixnum-mul spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##fixnum-sub spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##float-pack-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##float>integer-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##float>integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##fma-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##gather-int-vector-2 spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##gather-int-vector-4 spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##gather-vector-2 spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##gather-vector-4 spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##horizontal-add-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##horizontal-shl-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##horizontal-shr-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##horizontal-sub-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##integer>float-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##integer>float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##integer>scalar spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-double spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-memory-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-memory spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-reference spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-tagged spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##load-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##local-allot spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##log2 spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##max-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##max-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##max spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##merge-vector-head spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##merge-vector-tail spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##min-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##min-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##min spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mneg spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##move-vector-mask spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-high-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-horizontal-add-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul-wide-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##mul spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##neg spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##not-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##not spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##or-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##or-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##or spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors arrays assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces sequences ;

M: ##parallel-copy spill-rename-insn-defs
    [
        [
            first2 [ dup spill-def-renaming get at swap or ] dip
            2array
        ] map
    ] change-values drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##peek spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##phi spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##reload spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sad-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sar-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sar spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##saturated-add-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##saturated-mul-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##saturated-sub-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##scalar>integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##scalar>vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##select-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shl-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shl-vector-count spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shl-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shl-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shl spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shr-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shr-vector-count spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shr-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shr-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shr spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shuffle-vector-halves-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shuffle-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shuffle-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##shuffle2-vector-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##signed-pack-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##single>double-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##slot-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##slot spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sqrt-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sqrt spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sub-float spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sub-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sub-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##sub spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##tagged>integer spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##tail>head-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##test-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##test-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##test spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unary-vector-function spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unbox-alien spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unbox-any-c-ptr spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unbox-long-long spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst1
    [ dup spill-def-renaming get at swap or ] change-dst2 drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unbox spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unpack-vector-head spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unpack-vector-tail spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##unsigned-pack-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##vector>scalar spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##vm-field spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##xor-imm spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##xor-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##xor spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces ;

M: ##zero-vector spill-rename-insn-defs
    [ dup spill-def-renaming get at swap or ] change-dst drop ;


USING: accessors arrays assocs compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel
namespaces sequences ;

M: alien-call-insn spill-rename-insn-defs
    [
        [
            first3
            [ dup spill-def-renaming get at swap or ] 2dip
            3array
        ] map
    ] change-reg-outputs drop ;


USING: compiler.cfg.instructions
compiler.cfg.register-allocation.chordal.spilling kernel ;

M: insn spill-rename-insn-defs drop ;