compiler.tree vocabulary
Factor handbook » Vocabulary index

Documentation
High-level optimizer operating on lexical tree SSA IR

Metadata

Parents:	compiler
Authors:	Slava Pestov

Words

Tuple classes

Class	Superclass	Slots
#alien-assembly	#alien-node
#alien-callback	node	params child
#alien-indirect	#alien-node
#alien-invoke	#alien-node
#alien-node	node	params in-d out-d
#branch	node	in-d children live-branches
#call	node	word in-d out-d body method class info
#call-recursive	node	label in-d out-d info
#copy	#renaming	in-d out-d
#declare	node	declaration
#dispatch	#branch
#enter-recursive	node	in-d out-d label info
#if	#branch
#introduce	node	out-d
#phi	node	phi-in-d phi-info-d out-d terminated
#push	node	literal out-d
#recursive	node	in-d word label loop? child
#renaming	node
#return	node	in-d info
#return-recursive	#renaming	in-d out-d label info
#shuffle	#renaming	mapping in-d out-d in-r out-r
#terminate	node	in-d in-r
node	identity-tuple

Generic words

Word	Stack effect
inputs/outputs	( #renaming -- inputs outputs )

Ordinary words

Word	Stack effect
<#call-recursive>	( inputs outputs label -- node )
<#call>	( inputs outputs word -- node )
<#copy>	( inputs outputs -- node )
<#data-shuffle>	( in-d out-d mapping -- node )
<#declare>	( declaration -- node )
<#dispatch>	( n branches -- node )
<#drop>	( inputs -- node )
<#enter-recursive>	( label inputs outputs -- node )
<#if>	( ? true false -- node )
<#introduce>	( out-d -- node )
<#phi>	( d-phi-in d-phi-out terminated -- node )
<#push>	( literal value -- node )
<#recursive>	( label inputs child -- node )
<#return-recursive>	( label inputs outputs -- node )
<#return>	( stack -- node )
<#shuffle>	( in-d out-d in-r out-r mapping -- node )
ends-with-terminate?	( nodes -- ? )
new-branch	( value children class -- node )
node,	( node -- )

Class predicate words

Word	Stack effect
#alien-assembly?	( object -- ? )
#alien-callback?	( object -- ? )
#alien-indirect?	( object -- ? )
#alien-invoke?	( object -- ? )
#alien-node?	( object -- ? )
#branch?	( object -- ? )
#call-recursive?	( object -- ? )
#call?	( object -- ? )
#copy?	( object -- ? )
#declare?	( object -- ? )
#dispatch?	( object -- ? )
#enter-recursive?	( object -- ? )
#if?	( object -- ? )
#introduce?	( object -- ? )
#phi?	( object -- ? )
#push?	( object -- ? )
#recursive?	( object -- ? )
#renaming?	( object -- ? )
#return-recursive?	( object -- ? )
#return?	( object -- ? )
#shuffle?	( object -- ? )
#terminate?	( object -- ? )
node?	( object -- ? )

Files

resource:basis/compiler/tree/tree.factor
resource:basis/compiler/tree/tree-docs.factor
resource:basis/compiler/tree/tree-tests.factor

Metadata files

resource:basis/compiler/tree/authors.txt
resource:basis/compiler/tree/summary.txt

Children from resource:basis

Vocabulary	Summary
compiler.tree.builder	Constructing high-level tree IR
compiler.tree.checker	Debugging tool for checking various invariants of tree IR
compiler.tree.cleanup	Finalizing speculative inlining and constant folding from propagation pass
compiler.tree.combinators	Combinators for iterating over tree IR
compiler.tree.comparisons	Utilities for working with binary comparison operations
compiler.tree.dead-code	Dead code elimination
compiler.tree.debugger	Tools for debugging high-level optimizer
compiler.tree.def-use	Def/use chain construction
compiler.tree.escape-analysis	Escape analysis for tuple unboxing
compiler.tree.finalization	Final pass cleans up high-level IR
compiler.tree.identities	Applying arithmetic identities to integer code
compiler.tree.late-optimizations	Utilities used by several optimization passes run in the later stages
compiler.tree.modular-arithmetic	Modular arithmetic optimization
compiler.tree.normalization	Normalize IR created by high level IR builder to simplify subsequent passes
compiler.tree.optimizer	Top-level harness for high-level optimizer
compiler.tree.propagation	Class, interval, constant propagation
compiler.tree.recursive	Analysis of inline recursive combinators and loop detection
compiler.tree.tuple-unboxing	Tuple unboxing