MISRA C++:2023 Rule 8.2.10

Functions shall not call themselves, either directly or indirectly

Since R2024b

Description

Rule Definition

Functions shall not call themselves, either directly or indirectly. ¹

Rationale

Variables local to a function are stored in the call stack. If a function calls itself directly or indirectly several times, the available stack space can be exceeded, causing serious failure. Unless the recursion is tightly controlled, it is difficult to determine the maximum stack space required.

As an exception, constexpr functions that are called recursively only within a core constant expression do not violate this rule.

Polyspace Implementation

The checker reports each function that calls itself, directly or indirectly. Even if several functions are involved in one recursion cycle, each function is individually reported.

You can calculate the total number of recursion cycles using the code complexity metric Number of Recursions. Note that unlike the checker, the metric also considers implicit calls, for instance, to compiler-generated constructors during object creation.

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

Direct and Indirect Recursion

void foo1(int);
void foo2(int);

void foo1( int n ) {    // Non-compliant - Indirect recursion foo1->foo2->foo1...
    if(n > 0) {
        foo2(n);    
        foo1(n);    // Non-compliant - Direct recursion 
        n--;
    }     
}

void foo2( int n ) { // Non-compliant - Indirect recursion foo2->foo1->foo2... 
    foo1(n);
}

In this example, the rule is violated because of:

• Direct recursion foo1 → foo1.

• Indirect recursion foo1 → foo2 → foo1.

• Indirect recursion foo2 → foo1 → foo2.

Note that the location of the rule violation is different for direct and indirect recursions:

• When a function calls itself directly, the rule violation is shown on the function call.

• When several functions are involved in an indirect recursion chain, for every function in the chain, a rule violation is shown on the function signature in the function body.

Check Information

Group: Expressions

Category: Required

Version History

Introduced in R2024b

R2025a: Violation not reported on constexpr functions that are called only within a core constant expression

Polyspace no longer reports a violation if a constexpr function is recursively called within a core constant expression. In this code, the constexpr function foo() is recursively called within a core constant expression. Polyspace does not report a violation.

#include <cstdint>
constexpr int32_t foo(int32_t x)
{
	if(x > 0){

		x = x * foo(x - 1);  // Compliant by exception

	}
	return x;
}