#shuffle
High-level optimizer operating on lexical tree SSA IR

Prev:	#declare
Next:	#call-recursive

Vocabulary
compiler.tree

Class description
SSA tree node that represents a stack shuffling operation such as swap. It has the following slots:

mapping

An assoc that shows how the shuffle output values (the keys) correspond to their inputs (the values).

Definition

IN: compiler.tree

TUPLE: #shuffle < #renaming mapping in-d out-d in-r out-r ;

Methods

USING: accessors assocs compiler.tree compiler.tree.checker
kernel sequences sets ;

M: #shuffle check-node*
    [
        [ mapping>> values ] [ [ in-d>> ] [ in-r>> ] bi append ]
        bi subset? [ "Bad mapping inputs" throw ] unless
    ] [
        [ mapping>> keys ] [ [ out-d>> ] [ out-r>> ] bi append ]
        bi set= [ "Bad mapping outputs" throw ] unless
    ] bi ;


USING: combinators compiler.tree compiler.tree.checker ;

M: #shuffle check-stack-flow*
    {
        [ check-in-d ]
        [ check-in-r ]
        [ check-out-d ]
        [ check-out-r ]
    } cleave ;


USING: accessors assocs compiler.tree
compiler.tree.dead-code.liveness ;

M: #shuffle compute-live-values* mapping>> at look-at-value ;


USING: compiler.cfg.builder compiler.cfg.registers
compiler.cfg.stacks compiler.tree kernel sequences ;

M: #shuffle emit-node
    [ out-vregs/stack ] keep store-height-changes first2
    [ ds-loc store-vregs ] [ rs-loc store-vregs ] bi* ;


USING: accessors assocs combinators.short-circuit compiler.tree
compiler.tree.finalization kernel sequences ;

M: #shuffle finalize*
    dup {
        [ [ in-d>> length ] [ out-d>> length ] bi = ]
        [ [ in-r>> length ] [ out-r>> length ] bi = ]
        [
            [ in-d>> ] [ out-d>> ] [ mapping>> ] tri
            [ at = ] curry 2all?
        ]
        [
            [ in-r>> ] [ out-r>> ] [ mapping>> ] tri
            [ at = ] curry 2all?
        ]
    } 1&& [ drop f ] when ;


USING: accessors assocs compiler.tree kernel ;

M: #shuffle inputs/outputs mapping>> unzip swap ;


USING: accessors compiler.tree compiler.tree.def-use kernel
sequences ;

M: #shuffle node-defs-values [ out-d>> ] [ out-r>> ] bi append ;


USING: accessors compiler.tree compiler.tree.def-use kernel
sequences ;

M: #shuffle node-uses-values [ in-d>> ] [ in-r>> ] bi append ;


USING: accessors combinators combinators.short-circuit
compiler.tree compiler.tree.debugger kernel make sequences ;

M: #shuffle node>quot
    {
        { [ dup #>r? ] [ drop \ >R , ] }
        { [ dup #r>? ] [ drop \ R> , ] }
        {
            [ dup { [ in-r>> empty? ] [ out-r>> empty? ] } 1&& ]
            [
                shuffle-effect
                [ pretty-shuffle ] [ % ] [ shuffle-node boa , ]
                ?if
            ]
        }
        [ drop "COMPLEX SHUFFLE" , ]
    } cond ;


USING: accessors combinators.short-circuit compiler.tree
compiler.tree.dead-code.liveness compiler.tree.dead-code.simple
kernel sequences ;

M: #shuffle remove-dead-code*
    [ filter-live ] change-in-d [ filter-live ] change-out-d
    [ filter-live ] change-in-r [ filter-live ] change-out-r
    [ filter-mapping ] change-mapping dup
    { [ in-d>> empty? ] [ in-r>> empty? ] } 1&& [ drop f ] when
    ;


USING: accessors assocs compiler.tree
compiler.tree.normalization.renaming ;

M: #shuffle rename-node-values*
    [ rename-values ] change-in-d [ rename-values ] change-in-r
    [ [ rename-value ] assoc-map ] change-mapping ;


USING: accessors assocs compiler.tree
compiler.tree.tuple-unboxing kernel ;

M: #shuffle unbox-tuples*
    [ flatten-values ] change-in-d
    [ flatten-values ] change-out-d
    [ flatten-values ] change-in-r
    [ flatten-values ] change-out-r
    [ unzip [ flatten-values ] bi@ zip ] change-mapping ;