Code that has no effect or is never executed (that is, dead or unreachable code) is typically the result of a coding error and can cause unexpected behavior. Such code is usually optimized out of a program during compilation. However, to improve readability and ensure that logic errors are resolved, it should be identified, understood, and eliminated.
Statements or expressions that have no effect should be identified and removed from code. Most modern compilers, in many cases, can warn about code that has no effect or is never executed. (See MSC00-C. Compile cleanly at high warning levels.)
Noncompliant Code Example
This noncompliant code example demonstrates how dead code can be introduced into a program [Fortify 2006]. The second conditional statement,
if (s), will never evaluate true because it requires that
s not be assigned
NULL, and the only path where
s can be assigned a non-null value ends with a
Remediation of dead code requires the programmer to determine why the code is never executed and then to resolve the situation appropriately. To correct the preceding noncompliant code, the
return is removed from the body of the first conditional statement.
Noncompliant Code Example
In this example, the
strlen() function is used to limit the number of times the function
s_loop() will iterate. The conditional statement inside the loop evaluates to true when the current character in the string is the null terminator. However, because
strlen() returns the number of characters that precede the null terminator, the conditional statement never evaluates true.
Removing the dead code depends on the intent of the programmer. Assuming the intent is to flag and process the last character before the null terminator, the conditional is adjusted to correctly determine if the
i refers to the index of the last character before the null terminator.
Noncompliant Code Example (Assignment)
In this noncompliant code example, the comparison of
b has no effect:
This code is likely a case of the programmer mistakenly using the equals operator
== instead of the assignment operator
Compliant Solution (Assignment)
The assignment of
a is now properly performed:
Noncompliant Code Example (Dereference)
In this example, a pointer increment and then a dereference occur, but the dereference has no effect:
Compliant Solution (Dereference)
Correcting this example depends on the intent of the programmer. For example, if dereferencing
p was a mistake, then
p should not be dereferenced.
If the intent was to increment the value referred to by
p, then parentheses can be used to ensure
p is dereferenced and then incremented. (See EXP00-C. Use parentheses for precedence of operation.)
Another possibility is that
p is being used to reference a memory-mapped device. In this case, the variable
p should be declared as
Noncompliant Code Example (if/else if)
A chain of if/else if statements is evaluated from top to bottom. At most, only one branch of the chain will be executed: the first one with a condition that evaluates to true. Consequently, duplicating a condition in a sequence of if/else if statements automatically leads to dead code.
Compliant Solution (if/else if)
In this compliant solution, the third conditional expression has been corrected.
Noncompliant Code Example (logical operators)
Using the same subexpression on either side of a logical operator is almost always a mistake. In this noncompliant code example, the rightmost subexpression of the controlling expression of each
if statement has no effect.
Compliant Solution (logical operators)
In this compliant solution, the rightmost subexpression of the controlling expression of each
if statement has been removed.
Noncompliant Code Example (Unconditional Jump)
Unconditional jump statements typically has no effect.
Compliant Solution (Unconditional Jump)
The continue statement has been removed from this compliant solution.
MSC12-EX1: In some situations, seemingly dead code may make software resilient. An example is the
default label in a
switch statement whose controlling expression has an enumerated type and that specifies labels for all enumerations of the type. (See MSC01-C. Strive for logical completeness.) Because valid values of an enumerated type include all those of its underlying integer type, unless enumeration constants are provided for all those values, the
default label is appropriate and necessary.
MSC04-C. Use comments consistently and in a readable fashion for an illustration.)MSC12-EX2: It is permissible to temporarily remove code that may be needed later. (See
MSC12-EX3: Unused functions and variables that are part of an exported library do not violate this guideline. Likewise, code that is never executed because it is
#ifdefed out does not violate this guideline, on the grounds that it could be subsequently used in another application, or built on a different platform.
The presence of code that has no effect or is never executed can indicate logic errors that may result in unexpected behavior and vulnerabilities. Such code can be introduced into programs in a variety of ways and eliminating it can require significant analysis.
Code not exercised by analysis
Finds statements or expressions that do not accomplish anything or statements that perform an unintended action.
Can detect the specific instance where code can never be reached because of a logical contradiction or a dead "default" in
Can detect the instances where code block is unreachable because of the syntactic structure of the code
Options detect unused local variables, nonconstant static variables and unused function parameters, or unreachable code respectively.
|LDRA tool suite|
8 D, 65 D, 105 D, I J, 139 S, 140 S, 57 S
There shall be no unreachable code in "else" block
|Polyspace Bug Finder|
Code does not execute
Default case is missing and may be reached
Size argument of function in
A project shall not contain unreachable code
There shall be no dead code
3110, 3112, 3307, 3404, 3426, 3427
|SonarQube C/C++ Plugin|
|S1764, S2589, S2583, S1116, S1172, S1763, S1862, S1065, S1656, S2754, S1751|
The default mode checks for unreachable code.
|V551, V606, V649, V779|
CVE-2014-1266 results from a violation of this rule. There is a spurious
goto fail statement on line 631 of sslKeyExchange.c. This
goto statement gets executed unconditionally, even though it is indented as if it were part of the preceding
if statement. As a result, the call to
sslRawVerify() (which would perform the actual signature verification) becomes dead code [ImperialViolet 2014].
|SEI CERT C++ Coding Standard||VOID MSC12-CPP. Detect and remove code that has no effect|
|ISO/IEC TR 24772||Unspecified Functionality [BVQ]|
Likely Incorrect Expressions [KOA]
Dead and Deactivated Code [XYQ]
|MISRA C:2012||Rule 2.2 (required)|