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

Prev:	#push
Next:	#call-recursive

Vocabulary
compiler.tree

Class description
SSA tree node that calls a word. It has the following slots:

word	The word to call.
in-d	Sequence of input variables to the call. The items are ordered from top to bottom of the stack.
out-d	Output values of the call.
body	If the called word is generic and inlined, then 'body' is a sequence of SSA nodes built from the inlined method.
method	If the called word is generic and inlined here, then 'method' contains the inlined quotation.
class	a class
info	If the called word is generic and inlined, then the info slot contains an assoc of value infos for the body of the inlined generic. It is set during the propagation pass of the optimizer.

Definition

IN: compiler.tree

TUPLE: #call < node word in-d out-d body method class info ;

Methods

USING: accessors compiler.tree compiler.tree.propagation.nodes
kernel sequences ;

M: #call annotate-node
    dup [ in-d>> ] [ out-d>> ] bi append (annotate-node) ;


USING: accessors combinators compiler.tree
compiler.tree.identities compiler.tree.propagation.info kernel
words ;

M: #call apply-identities*
    dup word>> "identities" word-prop [
        over node-input-infos find-identity [
            {
                { \ drop [ 0 select-input ] }
                { \ nip [ 1 select-input ] }
                [ simplify-to-constant ]
            } case
        ] when*
    ] when* ;


USING: compiler.tree compiler.tree.checker kernel ;

M: #call check-stack-flow* [ check-in-d ] [ check-out-d ] bi ;


USING: accessors combinators compiler.tree compiler.tree.cleanup
kernel ;

M: #call cleanup-tree*
    {
        { [ dup body>> ] [ cleanup-inlining ] }
        { [ dup cleanup-folding? ] [ cleanup-folding ] }
        {
            [ dup remove-overflow-check? ]
            [ remove-overflow-check ]
        }
        [ ]
    } cond ;


USING: compiler.tree compiler.tree.dead-code.liveness kernel ;

M: #call compute-live-values* nip look-at-inputs ;


USING: combinators compiler.tree
compiler.tree.modular-arithmetic kernel ;

M: #call compute-modular-candidates*
    {
        { [ dup modular-word? ] [ output-candidate ] }
        { [ dup low-order-word? ] [ input-candidiate ] }
        [ drop ]
    } cond ;


USING: accessors combinators compiler.cfg.builder
compiler.cfg.builder.blocks compiler.tree kernel words ;

M: #call emit-node
    dup word>> dup "intrinsic" word-prop
    [ nip ( block #call -- block' ) call-effect ]
    [ swap call-height emit-call ] if* ;


USING: accessors classes.tuple.private combinators compiler.tree
compiler.tree.escape-analysis.nodes
compiler.tree.escape-analysis.simple kernel slots.private ;

M: #call escape-analysis*
    dup word>> {
        { \ <tuple-boa> [ record-tuple-allocation ] }
        { \ slot [ record-slot-call ] }
        [ drop record-unknown-allocation ]
    } case ;


USING: accessors compiler.tree compiler.tree.finalization kernel
;

M: #call finalize* dup word>> finalize-word ;


USING: compiler.tree compiler.tree.dead-code.liveness
compiler.tree.dead-code.simple kernel ;

M: #call mark-live-values*
    dup flushable-call? [ drop ] [ look-at-inputs ] if ;


USING: accessors compiler.tree compiler.tree.debugger make ;

M: #call node>quot word>> , ;


USING: combinators.short-circuit compiler.tree
compiler.tree.modular-arithmetic ;

M: #call only-reads-low-order?
    {
        [ low-order-word? ]
        [ { [ modular-word? ] [ output-modular? ] } 1&& ]
    } 1|| ;


USING: combinators compiler.tree
compiler.tree.modular-arithmetic kernel ;

M: #call optimize-modular-arithmetic*
    {
        { [ dup like->fixnum? ] [ optimize->fixnum ] }
        { [ dup like->integer? ] [ optimize->integer ] }
        { [ dup modular-word? ] [ optimize-modular-op ] }
        { [ dup low-order-word? ] [ optimize-low-order-op ] }
        [ ]
    } cond ;


USING: accessors compiler.tree compiler.tree.propagation.info
compiler.tree.propagation.nodes compiler.tree.propagation.simple
kernel ;

M: #call propagate-after
    dup word>> word>input-infos propagate-input-infos ;


USING: accessors combinators compiler.tree
compiler.tree.propagation.info
compiler.tree.propagation.inlining
compiler.tree.propagation.nodes compiler.tree.propagation.simple
kernel ;

M: #call propagate-before
    dup word>> {
        { [ 2dup foldable-call? ] [ fold-call ] }
        {
            [ 2dup do-inlining ]
            [
                [ output-value-infos ] [ drop out-d>> ] 2bi
                refine-value-infos
            ]
        }
        [
            [
                [ output-value-infos ] [ drop out-d>> ] 2bi
                set-value-infos
            ] [ compute-constraints ] 2bi
        ]
    } cond ;


USING: accessors combinators compiler.tree
compiler.tree.dead-code.liveness compiler.tree.dead-code.simple
kernel words ;

M: #call remove-dead-code*
    {
        {
            [ dup dead-flushable-call? ]
            [ remove-flushable-call ]
        }
        {
            [ dup word>> "simplifications" word-prop ]
            [ simplify-call ]
        }
        [ maybe-drop-dead-outputs ]
    } cond ;


USING: compiler.tree compiler.tree.escape-analysis.check
compiler.tree.propagation.info ;

M: #call run-escape-analysis* immutable-tuple-boa? ;


USING: accessors classes.tuple.private combinators compiler.tree
compiler.tree.tuple-unboxing kernel slots.private ;

M: #call unbox-tuples*
    dup word>> {
        { \ <tuple-boa> [ unbox-<tuple-boa> ] }
        { \ slot [ unbox-slot-access ] }
        [ drop ]
    } case ;