Reaching definition

In compiler theory, a reaching definition for a given instruction is an earlier instruction whose target variable can reach (be assigned to) the given one without an intervening assignment. For example, in the following code:

d1 : y := 3
d2 : x := y

d1 is a reaching definition for d2. In the following, example, however:

d1 : y := 3
d2 : y := 4
d3 : x := y

d1 is no longer a reaching definition for d3, because d2 kills its reach: the value defined in d1 is no longer available and cannot reach d3.

As analysis

The similarly named reaching definitions is a data-flow analysis which statically determines which definitions may reach a given point in the code. Because of its simplicity, it is often used as the canonical example of a data-flow analysis in textbooks. The data-flow confluence operator used is set union, and the analysis is forward flow. Reaching definitions are used to compute use-def chains and def-use chains.

The data-flow equations used for a given basic block $S$ in reaching definitions are:

• ${{\rm {REACH}}}_{{{\rm {in}}}}[S]=\bigcup _{{p\in pred[S]}}{{\rm {REACH}}}_{{{\rm {out}}}}[p]$
• ${{\rm {REACH}}}_{{{\rm {out}}}}[S]={{\rm {GEN}}}[S]\cup ({{\rm {REACH}}}_{{{\rm {in}}}}[S]-{{\rm {KILL}}}[S])$

In other words, the set of reaching definitions going into $S$ are all of the reaching definitions from $S$'s predecessors, $pred[S]$. $pred[S]$ consists of all of the basic blocks that come before $S$ in the control flow graph. The reaching definitions coming out of $S$ are all reaching definitions of its predecessors minus those reaching definitions whose variable is killed by $S$ plus any new definitions generated within $S$.

For a generic instruction, we define the ${{\rm {GEN}}}$ and ${{\rm {KILL}}}$ sets as follows:

• ${{\rm {GEN}}}[d:y\leftarrow f(x_{1},\cdots ,x_{n})]=\{d\}$
• ${{\rm {KILL}}}[d:y\leftarrow f(x_{1},\cdots ,x_{n})]={{\rm {DEFS}}}[y]-\{d\}$

where ${{\rm {DEFS}}}[y]$ is the set of all definitions that assign to the variable $y$. Here $d$ is a unique label attached to the assigning instruction; thus, the domain of values in reaching definitions are these instruction labels.

Further reading

• Aho, Alfred V.; Sethi, Ravi & Ullman, Jeffrey D. (1986). Compilers: Principles, Techniques, and Tools. Addison Wesley. ISBN 0-201-10088-6.
• Appel, Andrew W. (1999). Modern Compiler Implementation in ML. Cambridge University Press. ISBN 0-521-58274-1.
• Cooper, Keith D. & Torczon, Linda. (2005). Engineering a Compiler. Morgan Kaufmann. ISBN 1-55860-698-X.
• Muchnick, Steven S. (1997). Advanced Compiler Design and Implementation. Morgan Kaufmann. ISBN 1-55860-320-4.
• Nielson F., H.R. Nielson; , C. Hankin (2005). Principles of Program Analysis. Springer. ISBN 3-540-65410-0.

See also

• Static single assignment form