MISRA C++:2023 Rule 0.2.1

Variables with limited visibility should be used at least once

Since R2024b

Description

Rule Definition

Variables with limited visibility should be used at least once ¹

Rationale

Unused variables take up unnecessary space without contributing to the program output. The presence of unused variables might also indicate a programming error, such as an incorrect variable being used elsewhere.

Polyspace Implementation

The rule checker reports violations on unused variables with internal linkage, for instance:

• Unused local variables

• Unused global variables declared static

• Unused global variables declared outside a header file with a const or constexpr qualifier but not an extern qualifier

• Unused global variables in an anonymous namespace

The rule violation is reported on the variable declaration.

The checker does not report violations on:

• Unused variables of class type with a user-defined constructor or destructor.

• Local variables of a function that contains assembly code in an asm block.

Troubleshooting

If you expect a rule violation but Polyspace^® does not report it, see Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Unused static Variables

#include <cstdint>

static int16_t sensor1; // Noncompliant
static int16_t sensor2; // Compliant

int16_t getSensorValues() {
    return sensor2;
}

In this example, the static variable sensor1 has internal linkage but is not used in the file. Therefore, the rule checker reports the declaration of sensor1 as a rule violation.

Check Information

Group: Language independent issues

Category: Advisory

Version History

Introduced in R2024b

R2025a: Violations not reported on local variable if function contains assembly code

If a function contains an asm block, Polyspace assumes that the asm block can read or write any variable in the current scope. Because all local variables in the function scope can be read or written to, Polyspace does not report violations of this rule on the local variables. For example, in this code, Polyspace assumes that the assembly code can read or write the local variables and does not report a violation.

#include <stdio.h>

int func() {
	int num = 10;
	double pi = 3.141592653589793;
	double remainder;

	// Inline assembly to calculate the remainder
	asm(
	    "fldl %1;"          // Load the value of pi onto the FPU stack
	    "fildl %2;"         // Load the integer num onto the FPU stack
	    "fprem;"            // Calculate the remainder of num / pi
	    "fstpl %0;"         // Store the result into remainder
	    : "=m"(remainder)   // Output operand
	    : "m"(pi), "m"(num)    // Input operands
	    : "st", "st(1)"     // Clobbered registers
	);



	return remainder;
}