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 in reaching definitions are:
![{\displaystyle {\rm {REACH}}_{\rm {in}}[S]=\bigcup _{p\in pred[S]}{\rm {REACH}}_{\rm {out}}[p]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/88d90a4df4dc3fd7d5f07094e1c86593b00e56c2)
![{\displaystyle {\rm {REACH}}_{\rm {out}}[S]={\rm {GEN}}[S]\cup ({\rm {REACH}}_{\rm {in}}[S]-{\rm {KILL}}[S])}](https://wikimedia.org/api/rest_v1/media/math/render/svg/fc62c65a0828cf46b792d3a87e3cffc4161382f0)
In other words, the set of reaching definitions going into are all of the reaching definitions from 's predecessors, . consists of all of the basic blocks that come before in the control flow graph. The reaching definitions coming out of are all reaching definitions of its predecessors minus those reaching definitions whose variable is killed by plus any new definitions generated within .
![{\displaystyle pred[S]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/14ff3a07bc9cc297ab8420c3251155d4b066f742)
For a generic instruction, we define the and sets as follows:
![{\displaystyle {\rm {GEN}}[d:y\leftarrow f(x_{1},\cdots ,x_{n})]=\{d\}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/ff7f9be7d2dc36f753cceeddbbef71e9fab32e1a)
![{\displaystyle {\rm {KILL}}[d:y\leftarrow f(x_{1},\cdots ,x_{n})]={\rm {DEFS}}[y]-\{d\}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/2da33640a2d7c543238f975c03ffdc9caeb4481a)
where is the set of all definitions that assign to the variable . Here is a unique label attached to the assigning instruction; thus, the domain of values in reaching definitions are these instruction labels.
![{\displaystyle {\rm {DEFS}}[y]}](https://wikimedia.org/api/rest_v1/media/math/render/svg/7ac2a74eaf464d0299fede5fd0aa0868aa2f78ad)
Further reading
- Aho, Alfred V.; Sethi, Ravi; & Ullman, Jeffrey D. (1986). Compilers: Principles, Techniques, and Tools. Addison Wesley. ISBN 0-201-10088-6.
{{cite book}}: CS1 maint: multiple names: authors list (link) - 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.
{{cite book}}: CS1 maint: multiple names: authors list (link) - 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.
{{cite book}}: CS1 maint: multiple names: authors list (link)