V2608. MISRA. The 'static' storage class specifier should be used in all declarations of object and functions that have internal linkage.

This diagnostic rule is based on the software development guidelines developed by MISRA (Motor Industry Software Reliability Association).

A function or object declared once with internal linkage will also have internal linkage when redeclared or defined. This may not be obvious to developers, and therefore you should explicitly specify the 'static' specifier in each declaration and definition.

For C++, this rule applies only to functions.

The following code does not comply with the rule, since the definition does not reflect the internal linkage type specified in the 'foo' function declaration with the 'static' keyword:

static void foo(int x);  //in header.h
void foo(int x)          //in source.cpp
{
  ....
}

According to the rule, the code fragment should be as follows:

static void foo(int x);  //in header.h
static void foo(int x)   //in source.cpp
{
  ....
}

In the example below, the definition of the 'foo' function with the 'extern' storage class specifier does not specify the external linkage type, as it might seem. The linkage type remains internal:

static void foo(int x);  //in header.h
extern void foo(int x)   //in source.cpp
{
  ....
}

The C Standard allows using such code, but in this case, it is misleading. According to MISRA, here is the correct option:

extern void foo(int x);  //in header.h
extern void foo(int x)   //in source.cpp
{
  ....
}

A similar example with a global variable that violates the MISRA C rule:

static short y;       //in header.h
extern short y = 10;  //in source.c

The 'y' variable has the internal linkage type. This may not be obvious. A valid option would be:

static short y;       //in header.h
static short y = 10;  //in source.c

or

extern short y;       //in header.h
extern short y = 10;  //in source.c

This diagnostic is classified as: