CERT C++: MSC40-C

Inline constraint not respected occurs when you refer to a file scope modifiable static variable in a nonstatic inlined function. The checker considers a variable as modifiable if it is not const-qualified.

For instance, var is a variable defined in an inline function func. g_step is a file scope modifiable static variable referred to in the same inlined function.

static int g_step;
inline void func (void) {
    int var = g_step++; // Violation
}

When you modify a static variable in multiple function calls, you expect to modify the same variable in each call. For instance, it is expected that each time func is called in the preceding code, the same instance of g_step is incremented.

If a function has an inlined and a noninlined definition in separate files, when you call the function, the C++ standard allows compilers to use either the inlined or the noninlined form (see ISO^®/IEC 9899:2011, sec. 6.7.4). If your compiler uses an inlined definition in one call and the noninlined definition in another, you are no longer modifying the same variable in both calls. This behavior defies the expectations from a static variable.

Use one of these fixes:

In this example, the inline function foo() increments the file scope static variable var and passes it by reference to myFunc. Polyspace^® reports violations of this rule on these operations.

typedef int int32_t;
typedef const int cint32_t;
static int32_t var = 42;

int32_t myFunc(cint32_t &arg1, cint32_t &arg2);

inline int32_t foo(int32_t num)
{
  var++; //Noncompliant
  return myFunc(num, var);  //Noncompliant
}

To fix the violations of this rule, declare foo() as a static function. This clarification resolves ambiguity regarding the use of static variable.

typedef int int32_t;
typedef const int cint32_t;
static int32_t var = 42;

int32_t myFunc(cint32_t &arg1, cint32_t &arg2);

static inline int32_t foo(int32_t num)
{
  var++; // Compliant
  return myFunc(num, var);  // Compliant
}