uses-vreg-reps ( insn -- reps )

Vocabulary

compiler.cfg.representations.preferred

Inputs

insn

an object

Outputs

reps

an object

Definition

IN: compiler.cfg.representations.preferred

GENERIC: uses-vreg-reps ( insn -- reps )

Methods

USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##abs-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##add-float uses-vreg-reps drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##add-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##add-sub-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##add-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##add uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture generic
sequences ;

M: ##alien-indirect uses-vreg-reps
    M\ ##alien-indirect uses-vreg-reps (call-next-method)
    int-rep prefix ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##and-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##and-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##and uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##andn-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##avg-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##bit-count uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##bit-test uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##box-alien uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##box-displaced-alien uses-vreg-reps
    drop { int-rep tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##box-long-long uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##box uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##callback-inputs uses-vreg-reps drop { } ;


USING: accessors compiler.cfg.instructions
compiler.cfg.representations.preferred sequences ;

M: ##callback-outputs uses-vreg-reps
    reg-inputs>> [ second ] map ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-branch uses-vreg-reps
    drop { tagged-rep tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-float-ordered-branch uses-vreg-reps
    drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-float-ordered uses-vreg-reps
    drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-float-unordered-branch uses-vreg-reps
    drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-float-unordered uses-vreg-reps
    drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-imm-branch uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-imm uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-integer-branch uses-vreg-reps
    drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-integer-imm-branch uses-vreg-reps
    drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-integer-imm uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare-integer uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##compare-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##compare uses-vreg-reps drop { tagged-rep tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##convert-integer uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##copy uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##dispatch uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##div-float uses-vreg-reps drop { double-rep double-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##div-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##dot-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##double>single-float uses-vreg-reps drop { double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##fixnum-add uses-vreg-reps drop { tagged-rep tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##fixnum-mul uses-vreg-reps drop { tagged-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##fixnum-sub uses-vreg-reps drop { tagged-rep tagged-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##float-pack-vector uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##float>integer-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##float>integer uses-vreg-reps drop { double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##gather-int-vector-2 uses-vreg-reps
    drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##gather-int-vector-4 uses-vreg-reps
    drop { int-rep int-rep int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##gather-vector-2 uses-vreg-reps
    [ rep>> scalar-rep-of ] [ rep>> scalar-rep-of ] bi 2array ;


USING: accessors combinators compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture
sequences.generalizations ;

M: ##gather-vector-4 uses-vreg-reps
    {
        [ rep>> scalar-rep-of ]
        [ rep>> scalar-rep-of ]
        [ rep>> scalar-rep-of ]
        [ rep>> scalar-rep-of ]
    } cleave 4 narray ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##horizontal-add-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##horizontal-shl-vector-imm uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##horizontal-shr-vector-imm uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##horizontal-sub-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##integer>float-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##integer>float uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##integer>scalar uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##load-memory-imm uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##load-memory uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##log2 uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##max-float uses-vreg-reps drop { double-rep double-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##max-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##max uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##merge-vector-head uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##merge-vector-tail uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##min-float uses-vreg-reps drop { double-rep double-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##min-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##min uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##move-vector-mask uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##mul-float uses-vreg-reps drop { double-rep double-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##mul-high-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##mul-horizontal-add-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##mul-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##mul-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##mul uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##neg uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##not-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##not uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##or-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##or-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##or uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##replace uses-vreg-reps drop { tagged-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##sad-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sar-imm uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sar uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##saturated-add-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##saturated-mul-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##saturated-sub-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##scalar>integer uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture ;

M: ##scalar>vector uses-vreg-reps rep>> scalar-rep-of 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##select-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##set-slot-imm uses-vreg-reps
    drop { tagged-rep tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##set-slot uses-vreg-reps
    drop { tagged-rep tagged-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##set-vm-field uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shl-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##shl-vector-imm uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shl-vector uses-vreg-reps
    [ rep>> ] [ drop int-scalar-rep ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shl uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shr-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##shr-vector-imm uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shr-vector uses-vreg-reps
    [ rep>> ] [ drop int-scalar-rep ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##shr uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##shuffle-vector-halves-imm uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##shuffle-vector-imm uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##shuffle-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##signed-pack-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##single>double-float uses-vreg-reps drop { float-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##slot-imm uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##slot uses-vreg-reps drop { tagged-rep int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##spill uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##sqrt-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sqrt uses-vreg-reps drop { double-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##store-memory-imm uses-vreg-reps
    [ rep>> ] [ drop int-rep ] bi 2array ;


USING: accessors combinators compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel
sequences.generalizations ;

M: ##store-memory uses-vreg-reps
    { [ rep>> ] [ drop int-rep ] [ drop int-rep ] } cleave
    3 narray ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sub-float uses-vreg-reps drop { double-rep double-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sub-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##sub-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##sub uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##tagged>integer uses-vreg-reps drop { tagged-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##tail>head-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##test-branch uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##test-imm-branch uses-vreg-reps drop { int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##test-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##test-vector-branch uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##test-vector uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##test uses-vreg-reps drop { int-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##unbox-alien uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##unbox-any-c-ptr uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##unbox-long-long uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##unbox uses-vreg-reps drop { tagged-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##unpack-vector-head uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##unpack-vector-tail uses-vreg-reps rep>> 1array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##unsigned-pack-vector uses-vreg-reps
    [ rep>> ] [ rep>> ] bi 2array ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred ;

M: ##vector>scalar uses-vreg-reps rep>> 1array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##write-barrier-imm uses-vreg-reps drop { tagged-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##write-barrier uses-vreg-reps drop { tagged-rep int-rep } ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##xor-imm uses-vreg-reps drop { int-rep } ;


USING: accessors arrays compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: ##xor-vector uses-vreg-reps [ rep>> ] [ rep>> ] bi 2array ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred cpu.architecture kernel ;

M: ##xor uses-vreg-reps drop { int-rep int-rep } ;


USING: accessors compiler.cfg.instructions
compiler.cfg.representations.preferred kernel sequences ;

M: alien-call-insn uses-vreg-reps
    [ reg-inputs>> ] [ stack-inputs>> ] bi append [ second ] map
    ;


USING: compiler.cfg.instructions
compiler.cfg.representations.preferred kernel ;

M: insn uses-vreg-reps drop { } ;