MISRA C:2025 Rule 8.4

R2026b

A compatible declaration shall be visible when an object or function with external linkage is defined

Since R2026b

Description

A compatible declaration shall be visible when an object or function with external linkage is defined ¹ .

Rationale

If a declaration is visible when an object or function is defined, it allows the compiler to check that the declaration and the definition are compatible.

This rule with MISRA C:2012 Rule 8.5 enforces the practice of declaring an object (or function) in a header file and including the header file in source files that define or use the object (or function).

Polyspace Implementation

The rule checker detects situations where:

An object or function is defined without a visible declaration.
There is a data type mismatch between the object or function declaration and definition. Such a mismatch also causes a compilation error.

The checker now flags tentative definitions (variables declared without an extern specifier and not explicitly defined). To avoid the rule violation, declare the variable static (defined in one file only), or declare the variable extern and follow the declaration with a definition.

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

expand all

Definition Without Visible Declaration

Header file:

/* file.h */
extern int var2; 
void func2(void);

Source file:

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

int var1 = 0;    /* Non compliant */
int var2 = 0;    /* Compliant */

void func1(void) {   /* Non compliant */
}

void func2(void) {   /* Compliant */
}

In this example, the definitions of var1 and func1 are noncompliant because they are not preceded by visible declarations.

Mismatch in Parameter Data Types

void func(int param1, int param2);

void func(int param1, unsigned int param2) { /* Non compliant */
}

In this example, the definition of func has a different parameter type from its declaration. The declaration mismatch might cause a compilation error. Polyspace^® flags the mismatch.

Tentative Definition of Variable

In this example, the tentative definitions of variables j and k are noncompliant.

int j; /* Non compliant */
int k; /* Non compliant */

Correction — Use static or extern

To fix these violations, you can:

Declare the variable j as static in the source file
Declare the variable k as extern in a header file and define it in the source file.

Header file:

/* file.h */
extern int k;

Source file:

/* file.c */
#include "file.h"
static int j; /* Compliant */
int k = 2; /* Compliant */

Check Information

Group: Declarations and Definitions

Category: Required

AGC Category: Required

PQL Name: std.misra_c_2025.R8_4

Version History

Introduced in R2026b