Consider the following example written in
C. int foo(void) { int a = 24; int b = 25; // Assignment to dead variable int c; c = a * 4; return c; b = 24; // Unreachable code return 0; } Simple analysis of the uses of values would show that the value of b after the first assignment is not used inside foo. Furthermore, b is declared as a local variable inside foo, so its value cannot be used outside foo. Thus, the variable b is
dead and an optimizer can reclaim its storage space and eliminate its initialization. Furthermore, because the first return statement is executed unconditionally and there is no label after it which a "goto" could reach, no feasible execution path reaches the second assignment to b. Thus, the assignment is
unreachable and can be removed. If the procedure had a more complex
control flow, such as a label after the return statement and a goto elsewhere in the procedure, then a feasible execution path might exist to the assignment to b. Also, even though some calculations are performed in the function, their values are not stored in locations accessible outside the
scope of this function. Furthermore, given the function returns a static value (96), it may be simplified to the value it returns (this simplification is called
constant folding). Most advanced compilers have options to activate dead-code elimination, sometimes at varying levels. A lower level might only remove instructions that cannot be executed. A higher level might also not reserve space for unused variables. A yet higher level might determine instructions or functions that serve no purpose and eliminate them. A common use of dead-code elimination is as an alternative to optional code inclusion via a
preprocessor. Consider the following code. // set DEBUG_MODE to false constexpr bool DEBUG_MODE = false; int main(void) { int a = 5; int b = 6; int c; c = a * (b / 2); if (DEBUG_MODE) { printf("%d\n", c); } return c; } Because the constant DEBUG_MODE will always evaluate to False (logic)| (due to being defined as so), the code inside the if statement can never be executed, and dead-code elimination would remove it entirely from the optimized program. This technique is common in
debugging to optionally activate blocks of code; using an optimizer with dead-code elimination eliminates the need for using a
preprocessor to perform the same task. In practice, much of the dead code that an optimizer finds is created by other transformations in the optimizer. For example, the classic techniques for operator
strength reduction insert new computations into the code and render the older, more expensive computations dead. Subsequent dead-code elimination removes those calculations and completes the effect (without complicating the strength-reduction algorithm). Historically, dead-code elimination was performed using information derived from
data-flow analysis. An algorithm based on
static single-assignment form (SSA) appears in the original journal article on
SSA form by Ron Cytron et al. Robert Shillingsburg (aka Shillner) improved on the algorithm and developed a companion algorithm for removing useless control-flow operations. ==Dynamic dead-code elimination==