MISRA C:2012 Rule 8.7

Functions and objects should not be defined with external linkage if they are referenced in only one translation unit

Description

This checker is deactivated in a default Polyspace^® as You Code analysis. See Checkers Deactivated in Polyspace as You Code Default Analysis (Polyspace Bug Finder Access).

Rule Definition

Functions and objects should not be defined with external linkage if they are referenced in only one translation unit.

Rationale

Compliance with this rule avoids confusion between your identifier and an identical identifier in another translation unit or library. If you restrict or reduce the visibility of an object by giving it internal linkage or no linkage, you or someone else is less likely to access the object inadvertently.

Polyspace Implementation

The rule checker flags:

Objects that are defined at file scope without the static specifier but used only in one file.
Functions that are defined without the static specifier but called only in one file.

If you intend to use the object or function in one file only, declare it static.

If your code does not contain a main function and you use options such as Variables to initialize (-main-generator-writes-variables) with value custom to explicitly specify a set of variables to initialize, the checker does not flag those variables. The checker assumes that in a real application, the file containing the main must initialize the variables in addition to any file that currently uses them. Therefore, the variables are used in more than one translation unit.

Polyspace Bug Finder™ and Polyspace Code Prover™ check this coding rule differently. The analyses can produce different results.

Additional Message in Report

Variable variable_name should have internal linkage.
Function function_name should have internal linkage.

Troubleshooting

If you expect a rule violation but do not see it, refer to Coding Standard Violations Not Displayed.

Examples

expand all

Variable with External Linkage Used in One File

Header file:

/* file.h */
extern int var;

First source file:

/* file1.c */
#include "file.h"

int var;    /* Compliant */
int var2;   /* Non compliant */
static int var3; /* Compliant */

void reset(void);

void reset(void) {
    var = 0;
    var2 = 0;
    var3 = 0;
}

Second source file:

/* file2.c */
#include "file.h"

void increment(int var2);

void increment(int var2) {
    var++;
    var2++;
}

In this example:

The declaration of var is compliant because var is declared with external linkage and used in multiple files.
The declaration of var2 is noncompliant because var2 is declared with external linkage but used in one file only.
It might appear that var2 is defined in both files. However, in the second file, var2 is a parameter with no linkage and is not the same as the var2 in the first file.
The declaration of var3 is compliant because var3 is declared with internal linkage (with the static specifier) and used in one file only.

Function with External Linkage Used in One File

Header file:

/* file.h */
extern int var;
extern void increment1 (void);

First source file:

/* file1.c */
#include "file.h"

int var;

void increment2(void);
static void increment3(void);
void func(void);

void increment2(void) { /* Non compliant */
    var+=2;
}

static void increment3(void) { /* Compliant */
    var+=3;
}

void func(void) {
    increment1();
    increment2();
    increment3();
}

Second source file:

/* file2.c */
#include "file.h"

void increment1(void) { /* Compliant */
    var++;
}

In this example:

The definition of increment1 is compliant because increment1 is defined with external linkage and called in a different file.
The declaration of increment2 is noncompliant because increment2 is defined with external linkage but called in the same file and nowhere else.
The declaration of increment3 is compliant because increment3 is defined with internal linkage (with the static specifier) and called in the same file and nowhere else.

Check Information

Group: Declarations and Definitions

Category: Advisory

AGC Category: Advisory

Documentation