>expr ( insn -- expr )

Vocabulary

compiler.cfg.gvn.expressions

Inputs

insn

an object

Outputs

expr

an object

Definition

IN: compiler.cfg.gvn.expressions

GENERIC: >expr ( insn -- expr )

Methods

USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##abs-vector >expr
    \ ##abs-vector swap [ src>> vreg>vn ] keep [ rep>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##add-float >expr
    \ ##add-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##add-imm >expr
    \ ##add-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##add-sub-vector >expr
    \ ##add-sub-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##add-vector >expr
    \ ##add-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##add >expr
    \ ##add swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##and-imm >expr
    \ ##and-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##and-vector >expr
    \ ##and-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##and >expr
    \ ##and swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##andn-vector >expr
    \ ##andn-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##avg-vector >expr
    \ ##avg-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##bit-count >expr
    \ ##bit-count swap [ src>> vreg>vn ] keep drop 2 f <array>
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##bit-test >expr
    \ ##bit-test swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##box-alien >expr
    \ ##box-alien swap [ src>> vreg>vn ] keep drop 2 f <array>
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##box-displaced-alien >expr
    \ ##box-displaced-alien swap [ displacement>> vreg>vn ] keep
    [ base>> vreg>vn ] keep [ base-class>> ] keep drop
    4 f <array> 3 swap [ set-array-nth ] keep 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##box-long-long >expr
    \ ##box-long-long swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ boxer>> ] keep [ gc-map>> ] keep
    drop 5 f <array> 4 swap [ set-array-nth ] keep 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##box >expr
    \ ##box swap [ src>> vreg>vn ] keep [ boxer>> ] keep
    [ rep>> ] keep [ gc-map>> ] keep drop 5 f <array> 4 swap
    [ set-array-nth ] keep 3 swap [ set-array-nth ] keep 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-float-ordered >expr
    \ ##compare-float-ordered swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ cc>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-float-unordered >expr
    \ ##compare-float-unordered swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ cc>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-imm >expr
    \ ##compare-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    [ cc>> ] keep drop 4 f <array> 3 swap [ set-array-nth ] keep
    2 swap [ set-array-nth ] keep 1 swap [ set-array-nth ] keep
    0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-integer-imm >expr
    \ ##compare-integer-imm swap [ src1>> vreg>vn ] keep
    [ src2>> ] keep [ cc>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-integer >expr
    \ ##compare-integer swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ cc>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare-vector >expr
    \ ##compare-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep [ cc>> ] keep drop
    5 f <array> 4 swap [ set-array-nth ] keep 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##compare >expr
    \ ##compare swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ cc>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##convert-integer >expr
    \ ##convert-integer swap [ src>> vreg>vn ] keep
    [ c-type>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: compiler.cfg.gvn.expressions compiler.cfg.instructions
kernel ;

M: ##copy >expr "Fail" throw ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##div-float >expr
    \ ##div-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##div-vector >expr
    \ ##div-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##dot-vector >expr
    \ ##dot-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##double>single-float >expr
    \ ##double>single-float swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.instructions kernel sequences.private ;

M: ##fill-vector >expr
    \ ##fill-vector swap [ rep>> ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##float-pack-vector >expr
    \ ##float-pack-vector swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##float>integer-vector >expr
    \ ##float>integer-vector swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##float>integer >expr
    \ ##float>integer swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##gather-int-vector-2 >expr
    \ ##gather-int-vector-2 swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##gather-int-vector-4 >expr
    \ ##gather-int-vector-4 swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ src3>> vreg>vn ] keep
    [ src4>> vreg>vn ] keep [ rep>> ] keep drop 6 f <array>
    5 swap [ set-array-nth ] keep 4 swap [ set-array-nth ] keep
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##gather-vector-2 >expr
    \ ##gather-vector-2 swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##gather-vector-4 >expr
    \ ##gather-vector-4 swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ src3>> vreg>vn ] keep
    [ src4>> vreg>vn ] keep [ rep>> ] keep drop 6 f <array>
    5 swap [ set-array-nth ] keep 4 swap [ set-array-nth ] keep
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##horizontal-add-vector >expr
    \ ##horizontal-add-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##horizontal-shl-vector-imm >expr
    \ ##horizontal-shl-vector-imm swap [ src1>> vreg>vn ] keep
    [ src2>> ] keep [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##horizontal-shr-vector-imm >expr
    \ ##horizontal-shr-vector-imm swap [ src1>> vreg>vn ] keep
    [ src2>> ] keep [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##horizontal-sub-vector >expr
    \ ##horizontal-sub-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##integer>float-vector >expr
    \ ##integer>float-vector swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##integer>float >expr
    \ ##integer>float swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##integer>scalar >expr
    \ ##integer>scalar swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors compiler.cfg.gvn.expressions
compiler.cfg.instructions ;

M: ##load-integer >expr val>> <integer-expr> ;


USING: accessors compiler.cfg.gvn.expressions
compiler.cfg.instructions ;

M: ##load-reference >expr obj>> <reference-expr> ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##log2 >expr
    \ ##log2 swap [ src>> vreg>vn ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##max-float >expr
    \ ##max-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##max-vector >expr
    \ ##max-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##max >expr
    \ ##max swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##merge-vector-head >expr
    \ ##merge-vector-head swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##merge-vector-tail >expr
    \ ##merge-vector-tail swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##min-float >expr
    \ ##min-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##min-vector >expr
    \ ##min-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##min >expr
    \ ##min swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##move-vector-mask >expr
    \ ##move-vector-mask swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul-float >expr
    \ ##mul-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul-high-vector >expr
    \ ##mul-high-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul-horizontal-add-vector >expr
    \ ##mul-horizontal-add-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul-imm >expr
    \ ##mul-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul-vector >expr
    \ ##mul-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##mul >expr
    \ ##mul swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##neg >expr
    \ ##neg swap [ src>> vreg>vn ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##not-vector >expr
    \ ##not-vector swap [ src>> vreg>vn ] keep [ rep>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##not >expr
    \ ##not swap [ src>> vreg>vn ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##or-imm >expr
    \ ##or-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep drop
    3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##or-vector >expr
    \ ##or-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##or >expr
    \ ##or swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors assocs compiler.cfg
compiler.cfg.gvn.expressions compiler.cfg.gvn.graph
compiler.cfg.instructions namespaces sequences ;

M: ##phi >expr
    inputs>> values [ vreg>vn ] map
    basic-block get number>> prefix ##phi prefix ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sad-vector >expr
    \ ##sad-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sar-imm >expr
    \ ##sar-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sar >expr
    \ ##sar swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##saturated-add-vector >expr
    \ ##saturated-add-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##saturated-mul-vector >expr
    \ ##saturated-mul-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##saturated-sub-vector >expr
    \ ##saturated-sub-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##scalar>integer >expr
    \ ##scalar>integer swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##scalar>vector >expr
    \ ##scalar>vector swap [ src>> vreg>vn ] keep [ rep>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##select-vector >expr
    \ ##select-vector swap [ src>> vreg>vn ] keep [ n>> ] keep
    [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shl-imm >expr
    \ ##shl-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shl-vector-imm >expr
    \ ##shl-vector-imm swap [ src1>> vreg>vn ] keep
    [ src2>> ] keep [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shl-vector >expr
    \ ##shl-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shl >expr
    \ ##shl swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shr-imm >expr
    \ ##shr-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shr-vector-imm >expr
    \ ##shr-vector-imm swap [ src1>> vreg>vn ] keep
    [ src2>> ] keep [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shr-vector >expr
    \ ##shr-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shr >expr
    \ ##shr swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shuffle-vector-halves-imm >expr
    \ ##shuffle-vector-halves-imm swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ shuffle>> ] keep [ rep>> ] keep
    drop 5 f <array> 4 swap [ set-array-nth ] keep 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shuffle-vector-imm >expr
    \ ##shuffle-vector-imm swap [ src>> vreg>vn ] keep
    [ shuffle>> ] keep [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##shuffle-vector >expr
    \ ##shuffle-vector swap [ src>> vreg>vn ] keep
    [ shuffle>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##signed-pack-vector >expr
    \ ##signed-pack-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##single>double-float >expr
    \ ##single>double-float swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sqrt-vector >expr
    \ ##sqrt-vector swap [ src>> vreg>vn ] keep [ rep>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sqrt >expr
    \ ##sqrt swap [ src>> vreg>vn ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sub-float >expr
    \ ##sub-float swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sub-imm >expr
    \ ##sub-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sub-vector >expr
    \ ##sub-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##sub >expr
    \ ##sub swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##tagged>integer >expr
    \ ##tagged>integer swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##tail>head-vector >expr
    \ ##tail>head-vector swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##test-imm >expr
    \ ##test-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    [ cc>> ] keep drop 4 f <array> 3 swap [ set-array-nth ] keep
    2 swap [ set-array-nth ] keep 1 swap [ set-array-nth ] keep
    0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##test-vector >expr
    \ ##test-vector swap [ src1>> vreg>vn ] keep [ rep>> ] keep
    [ vcc>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##test >expr
    \ ##test swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ cc>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unbox-alien >expr
    \ ##unbox-alien swap [ src>> vreg>vn ] keep drop 2 f <array>
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unbox-any-c-ptr >expr
    \ ##unbox-any-c-ptr swap [ src>> vreg>vn ] keep drop
    2 f <array> 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unbox-long-long >expr
    \ ##unbox-long-long swap [ src>> vreg>vn ] keep
    [ unboxer>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unbox >expr
    \ ##unbox swap [ src>> vreg>vn ] keep [ unboxer>> ] keep
    [ rep>> ] keep drop 4 f <array> 3 swap
    [ set-array-nth ] keep 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unpack-vector-head >expr
    \ ##unpack-vector-head swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unpack-vector-tail >expr
    \ ##unpack-vector-tail swap [ src>> vreg>vn ] keep
    [ rep>> ] keep drop 3 f <array> 2 swap
    [ set-array-nth ] keep 1 swap [ set-array-nth ] keep 0 swap
    [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##unsigned-pack-vector >expr
    \ ##unsigned-pack-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##vector>scalar >expr
    \ ##vector>scalar swap [ src>> vreg>vn ] keep [ rep>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##xor-imm >expr
    \ ##xor-imm swap [ src1>> vreg>vn ] keep [ src2>> ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##xor-vector >expr
    \ ##xor-vector swap [ src1>> vreg>vn ] keep
    [ src2>> vreg>vn ] keep [ rep>> ] keep drop 4 f <array>
    3 swap [ set-array-nth ] keep 2 swap [ set-array-nth ] keep
    1 swap [ set-array-nth ] keep 0 swap [ set-array-nth ] keep
    ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.gvn.graph compiler.cfg.instructions kernel
sequences.private ;

M: ##xor >expr
    \ ##xor swap [ src1>> vreg>vn ] keep [ src2>> vreg>vn ] keep
    drop 3 f <array> 2 swap [ set-array-nth ] keep 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: accessors arrays compiler.cfg.gvn.expressions
compiler.cfg.instructions kernel sequences.private ;

M: ##zero-vector >expr
    \ ##zero-vector swap [ rep>> ] keep drop 2 f <array> 1 swap
    [ set-array-nth ] keep 0 swap [ set-array-nth ] keep ;


USING: compiler.cfg.gvn.expressions compiler.cfg.gvn.graph
compiler.cfg.instructions kernel math namespaces ;

M: insn >expr drop input-expr-counter counter neg ;