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

Prev:	#alien-callback
Next:	#if

Vocabulary
compiler.tree

Definition

IN: compiler.tree

TUPLE: #branch < node in-d children live-branches ;

Methods

USING: accessors compiler.tree compiler.tree.checker kernel
namespaces sequences ;

M: #branch check-stack-flow*
    [ check-in-d ]
    [ children>> [ check-branch ] map branch-out set ] bi ;


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

M: #branch cleanup-tree*
    {
        [ delete-unreachable-branches ]
        [ cleanup-children ]
        [ fold-only-branch ]
        [ live-branches>> live-branches set ]
    } cleave ;


USING: accessors compiler.tree
compiler.tree.normalization.introductions math.order sequences ;

M: #branch count-introductions*
    children>> [ count-introductions ] [ max ] map-reduce
    introductions+ ;


USING: accessors compiler.tree
compiler.tree.escape-analysis.allocations
compiler.tree.escape-analysis.nodes
compiler.tree.propagation.branches kernel sequences ;

M: #branch escape-analysis*
    [ in-d>> add-escaping-values ]
    [ live-children [ [ (escape-analysis) ] when* ] each ] bi ;


USING: accessors compiler.tree compiler.tree.recursive.private
kernel sequences ;

M: #branch node-call-graph
    children>> [ (build-call-graph) ] with each ;


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

M: #branch node-defs-values drop f ;


USING: accessors arrays assocs compiler.tree
compiler.tree.normalization compiler.utilities kernel math.order
namespaces sequences ;

M: #branch normalize*
    [
        [
            [
                [ normalize* ] map-flat
                introduction-stack get 2array
            ] with-scope
        ] map unzip swap
    ] change-children swap
    [ remaining-introductions set ] [
        [ length ] [ min ] map-reduce introduction-stack
        [ swap head ] change
    ] bi ;


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

M: #branch propagate-around
    dup live-branches >>live-branches
    [ infer-children ] [ annotate-node ] bi ;


USING: accessors compiler.tree compiler.tree.dead-code.branches
compiler.tree.dead-code.liveness kernel namespaces sequences ;

M: #branch remove-dead-code*
    [ [ [ (remove-dead-code) ] map ] change-children ]
    [ if-node set ] bi ;


USING: accessors compiler.tree
compiler.tree.escape-analysis.check sequences ;

M: #branch run-escape-analysis*
    children>> [ run-escape-analysis? ] any? ;


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

M: #branch unbox-tuples* dup in-d>> assert-not-unboxed ;