MISRA C:2012 Rule 2.1

R2026b

A project shall not contain unreachable code

Description

A project shall not contain unreachable code¹ .

Rationale

Unless a program exhibits any undefined behavior, unreachable code cannot execute. The unreachable code cannot affect the program output. The presence of unreachable code can indicate an error in the program logic. Unreachable code that the compiler does not remove wastes resources, for example:

• It occupies space in the target machine memory.

• Its presence can cause a compiler to select longer, slower jump instructions when transferring control around the unreachable code.

• Within a loop, it can prevent the entire loop from residing in an instruction cache.

Polyspace Implementation

Polyspace^® reports a violation of this rule when a statement in your code is not reachable.

The checker flags these patterns as unreachable code:

• A statement follows a return, break, or unconditional goto statement

• A static function is defined but never called in the same translation unit

• Code is inside a constant-false branch such as if(0)

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Code Following return Statement

enum light { red, amber, red_amber, green };

enum light next_light ( enum light color )
{
    enum light res;

    switch ( color )
    {
    case red:
        res = red_amber;
        break;
    case red_amber:
        res = green;
        break;
    case green:
        res = amber;
        break;
    case amber:
        res = red;
        break;
    default:
    {
        error_handler ();
        break;
    }
    }

    res = color;
    return res;
    res = color;     /* Non-compliant */
}

In this example, the rule is violated because there is an unreachable operation following the return statement.

Dead Code in Constant-False Branch

In this example, the function contains a branch with a controlling expression that always evaluates to zero.

int process_value(int input) {
    int result = input * 2;

    if (0) {                  // Noncompliant - controlling expression is always false
        result = input + 1;
    }

    return result;
}

Polyspace reports a violation of this rule because the code inside the if(0) branch is unreachable. The controlling expression is a compile-time constant that evaluates to zero, so the statements inside the branch can never execute.

Check Information

Group: Unused Code

Category: Required

AGC Category: Required

PQL Name: std.misra_c_2012.R2_1

Version History

Introduced in R2014b

R2026b: Dead code in constant-false branches now detected

The rule checker now reports a violation when code is inside a constant-false branch such as if(0). Previously, these patterns were not flagged as unreachable code.

int func(void) {
    if (0) {               // Newly detected
        return 3;
    }
    return 0;
}

R2023a: Static uncalled functions flagged

The rule checker reports a violation of this rule when you do not call a static function in the same file where you define the function.

For instance, the rule checker flags the function initialize that is defined as static but not called in the same file:

#include <stdlib.h>
#include <stdio.h>

static int initialize(void)    //Noncompliant
  {
   int input;
   printf("Enter an integer:");
   scanf("%d",&input);
   return(input);
  }
  
 void main()
  {
   int num;
   num=0;
   printf("The value of num is %d",num);
  }