Page History

The previous standard of C90 allowed for C23 Standard requires type specifiers and forbids implicit function declarations. The C90 Standard allows implicit typing of variables and functions. Since implicit declarations lead to less stringent type checking, they can often introduce unexpected and erroneous behavior or even security vulnerabilities.Two new features of C99 are to require type identifiers and to forbid implicit function declarations. The effect is to guarantee the production of a diagnostic that will catch an additional category of 25 programming errors. After issuing the diagnostic, an . Consequently, some existing legacy code uses implicit typing. Some C compilers still support legacy code by allowing implicit typing, but it should not be used for new code. Such an implementation may choose to assume an implicit declaration and continue translation to support existing programs that exploited used this feature.

...

Noncompliant Code Example (

...

Implicit int)

Don't rely on implicit int typing. C99 Section C no longer allows the absence of type specifiers in a declaration. The C Standard, 6.7.3 paragraph 2 , "Type specifiers" states:[ ISO/IEC 9899:2024 ], states

Except where the type is inferred (6.7.10), at At least one type specifier shall be given in the declaration specifiers in each declaration, and in the specifier-qualifier list in each struct member declaration and type name.

This noncompliant code example omits the type specifier:

extern foo;

Most C90 Some C implementations do not issue a diagnostic for the violation of this C99 constraint. Many C99 These nonconforming C translators will continue to treat such declaration declarations as implying the type int.

Compliant

...

Solution (Implicit int)

This compliant solution explicitly includes a type specifier:

extern int foo;

...

Noncompliant Code Example (

...

Implicit Function Declaration)

Implicit declaration of functions is not allowed: ; every function must be explicitly declared before it can be called. In C89C90, if a function is called without an explicit prototype, the compiler provides an implicit declaration.

The C90 Standard included the Standard [ISO/IEC 9899:1990] includes this requirement:

If the expression that precedes the parenthesized argument list in a function call consists solely of an identifier, and if no declaration is visible for this identifier, the identifier is implicitly declared exactly as if, in the innermost block containing the function call, the declaration extern int identifier(); appeared.

A C99 implementation will not perform implicit function declarations.

If a function declaration is not visible at the point at which a call to the function is made, some compilers C90-compliant platforms assume an implicit declaration of extern int funcidentifier(); However, for conformance to C99, you should .

This declaration implies that the function may take any number and type of arguments and return an int. However, to conform to the current C Standard, programmers must explicitly prototype every function before making a call to it.invoking it. An implementation that conforms to the C Standard may or may not perform implicit function declarations, but C does require a conforming implementation to issue a diagnostic if it encounters an undeclared function being used.

In this noncompliant code example, if malloc() is not declared, either explicitly or by including stdlib.h, a compiler that conforms only to C90 may implicitly declare malloc() as int malloc(). If the platform's size of int is 32 bits, but the size of pointers is 64 bits, the resulting pointer would likely be truncated as a result of the implicit declaration of malloc(), returning a 32-bit integer.

#include <stddef.h>
/* #include <stdlib.h> is missing */
 

int main(void) {
  for  int c = foo();(size_t i = 0; i < 100; ++i) {
    /* int malloc() assumed */
    printf("%d\n", cchar *ptr = (char *)malloc(0x10000000);
    *ptr return= 0'a';
}

int foo(int a) { }
  return a0;
}

Since the compiler assumes foo() to have type extern int foo(), it cannot spot the missing argument and a bogus value is printed.

Compliant Solution (Implicit Function Declaration)

This compliant solution declares malloc() by including the appropriate header file:

...

#include <stdlib.h>
int foo(int);

int main(void) {
  for (size_t inti c = foo(0);0; i < 100; ++i) {
    printf("%d\n", cchar *ptr = (char *)malloc(0x10000000);
    return 0;
}

int foo(int a) {*ptr = 'a';
  }
  return a0;
}

...

For more information on function declarations see \[[declarations, see DCL07-AC. Include the appropriate type information in function declarators]\]

...

.

Noncompliant Code Example (

...

Implicit Return Type)

Similarly, don't Do not declare a function with implicit an implicit return type. If it returns For example, if a function returns a meaningful integer value, declare it it as returning int. If it returns no meaningful value, declare it it as returning void.

#include <limits.h>
#include <stdio.h>
 
foo(void) {
  return UINT_MAX;
}

int main(void) {
  long long int c = foo();
  printf("%lld\n", c);
  return 0;
}

Since Because the compiler assumes that foo() returns a value of type int for this noncompliant code example, UINT_MAX is incorrectly converted to -1 −1.

Compliant Solution (

...

Implicit Return Type)

This compliant solution explicitly defines the return type of foo() as unsigned int. As a result, the function correctly returns UINT_MAX .

#include <limits.h>
#include <stdio.h>

unsigned int foo(void) {
  return UINT_MAX;
}

int main(void) {
  long long int c = foo();
  printf("%lld\n", c);
  return 0;
}

Risk Assessment

Because implicit declarations lead to less stringent type checking, they can introduce unexpected and erroneous behavior. Occurrences of an omitted type specifier in existing code is are rare, and the consequences are generally minor, perhaps resulting in abnormal program termination.

Automated Detection

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

...

Related Guidelines

Key here (explains table format and definitions)

Bibliography

...

...

...

...

Image Added Image Added Image Added specifiers", Section 6.5.2.2, "Function calls" \[[Jones 08|AA. C References#Jones 08]\] \[[MISRA 04|AA. C References#MISRA 04]\]Image Removed      02. Declarations and Initialization (DCL)       DCL32-C. Guarantee that mutually-visible identifiers are unique