Unreachable code is a computer programming term for code in the source code of a program which can never be executed because there exists no control flow path to the code from the rest of the program.[1]
Unreachable code is sometimes also called dead code[citation needed], although dead code may also refer to code that is executed but has no effect on the output of a program.
Unreachable code is generally considered undesirable for a number of reasons, including:
- Occupies unnecessary memory
- Causes unnecessary caching of instructions into the CPU instruction cache - which also decreases data locality.
- From the perspective of program maintenance; time and effort may be spent maintaining and documenting a piece of code which is in fact unreachable, hence never executed.
Causes
The existence of unreachable code can be due to various factors, such as:
- complex conditional branches in which a case is never reachable;
- as a consequence of the internal transformations performed by an optimizing compiler;
- improper maintenance of a program or from debugging constructs and vestigial development code which have yet to be removed from a program.
In the latter case, code which is currently unreachable is there as part of a legacy. The distinguishing point in that case is that this part of code was once useful but is no longer used or required.
Examples
Consider the following fragment of C code:
int f (int x, int y)
{
return x+y;
int z=x*y;
}
The definition int z=x*y; is never reached as the function returns before the definition is reached. Therefore the definition of z can be discarded.
Analysis
Detecting unreachable code is a form of static analysis and involves performing control flow analysis to find any code that will never be executed regardless of the values of variables and other conditions at run time. In some languages (e.g. Java) some forms of unreachable code are explicitly disallowed. The optimization that removes unreachable code is known as dead code elimination.
Code may become unreachable as a consequence of the internal transformations performed by an optimizing compiler (e.g., common subexpression elimination). There are probably other specialized domains that also make use of this term.
In practice the sophistication of the analysis performed has a significant impact on the amount of unreachable code that is detected. For example, constant folding and simple flow analysis shows that the statement xyz in the following code is unreachable:
int n = 2 + 1;
if (n == 4)
{
xyz
}
However, a great deal more sophistication is needed to work out that the statement xyz is unreachable in the following code:
double x = sqrt(2);
if (x > 5)
{
xyz
}
The unreachable code elimination technique is in the same class of optimizations as dead code elimination and redundant code elimination.
Unreachability vs. profiling
In some cases, a practical approach may be a combination of simple unreachability criteria and use of a profiler to handle the more complex cases. Profiling in general can not prove anything about the unreachability of a piece of code, but may be a good heuristic for finding potentially unreachable code. Once a suspect piece of code is found, other methods, such as a more powerful code analysis tool, or even analysis by hand, could be used to decide whether the code is truly unreachable.
References
- Appel, A. W. 1998 Modern Compiler Implementation in Java. Cambridge University Press.
- Muchnick S. S. 1997 Advanced Compiler Design and Implementation. Morgan Kaufmann.
See also
