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.

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

* _ = \bigcup_ _ /math>
* _ = \cup (_ -

In other words, the set of reaching definitions going into $S$ are all of the reaching definitions from $S$'s predecessors, pred /math>. pred /math> 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 $$ and $$ sets as follows:

* : y \leftarrow f(x_1,\cdots,x_n)= \ , a set of locally available definitions in a basic block
* : y \leftarrow f(x_1,\cdots,x_n)= - \, a set of definitions (not locally available, but in the rest of the program) killed by definitions in the basic block.

where /math> 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.

Worklist algorithm

Reaching definition is usually calculated using an iterative worklist algorithm.

Input: control-flow graph CFG = (Nodes, Edges, Entry, Exit)

// Initialize
for all CFG nodes n in N,
OUT = emptyset; // can optimize by OUT = GEN

// put all nodes into the changed set
// N is all nodes in graph,
Changed = N;

// Iterate
while (Changed != emptyset)

See also

* Dead-code elimination
* Loop-invariant code motion
* Reachable uses
* Static single assignment form

Further reading

*
*
*
*
*{{cite book
, author1=Nielson F., H.R. Nielson , author2=, C. Hankin , title=Principles of Program Analysis
, publisher=Springer
, year=2005
, isbn=3-540-65410-0

Data-flow analysis
Program analysis