Page History

...

Attempting to compile a program with a function declarator that does not include the appropriate type information typically generates a warning but does not prevent program compilation. These warnings should be resolved. (see See MSC00-AC. Compile cleanly at high warning levels.).

...

Noncompliant Code Example (Non-Prototype-Format Declarators)

The non-compliant This noncompliant code example uses the identifier-list form for parameter declarations.:

int max(a, b)
int a, b;
{
  return a > b ? a : b;
}

Section Subclause 6.11 of the C99 standard, "Future language directions," states that "The .7 of the C Standard [ISO/IEC 9899:2011] states that "the use of function definitions with separate parameter identifier and declaration lists (not prototype-format parameter type and identifier declarators) is an obsolescent feature."

Compliant Solution (Non-Prototype-Format Declarators)

In this compliant solution, int is the type specifier, max(int a, int b) is the function declarator, and the block within the curly braces is the function body.:

int max(int a, int b) {
  return a > b ? a : b;
}

...

Noncompliant Code Example (Function Prototypes)

Declaring a function without any prototype forces the compiler to assume that the correct number and type of parameters have been supplied to a function. This practice can result in unintended and undefined behavior.

In this non-compliant noncompliant code example, which involves two files, the definition of func() in file_a.c expects three parameters but is supplied only two. However, because there is no prototype for func() in the second file, the compiler assumes that the correct number of arguments has been supplied and uses the next value on the program stack as the missing third argument.:

/* file_a.c source file */
int func(int one, int two, int three){
  printf("%d %d %d", one, two, three);
  return 1;
}

However, because there is no prototype for func() in file_b.c, the compiler assumes that the correct number of arguments has been supplied and uses the next value on the program stack as the missing third argument:

/* file_b.c source file */
func(1, 2);

...

C99 eliminated implicit function declarations from the C language \[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\]. However, many compilers still allow the compilation of programs containing implicitly declared functions, although they may issue a warning message. These warnings should be resolved . (see [See MSC00-AC. Compile cleanly at high warning levels].).

Compliant Solution (Function Prototypes)

To correct this example, the appropriate This compliant solution correctly includes the function prototype for func() should be specified in the file compilation unit in which it is invoked. This allows the compiler to diagnose invalid function , and the function invocation has been corrected to pass the right number of arguments:

int func(int, int, int);

func(1, 2);

The user can then correct the code:

int func(int one, int two, int three){
  printf("%d %d %d", one, two, three);
  return 1;
}

/* file_b.c source file */

int func(int, int, int);

func(1, 2, 3);

...

Noncompliant Code Example (Function Pointers)

If a function pointer refers to an incompatible function, invoking that function via the pointer may corrupt the process stack. As a result, unexpected data may be accessed by the called function.

In this non-compliant noncompliant code example, the function pointer fn_ptr refers to the function add(), which accepts three integer arguments. However, fn_ptr is specified to accept two integer arguments. Setting fn_ptr to refer to add() results in unexpected program behavior. This example also violates the rule DCL35violates EXP37-C. Do not convert a function pointer to an incompatible type.Call functions with the correct number and type of arguments:

int add(int x, int y, int z) {
   return x + y + z;
}

int main(int argc, char *argv[]) {
   int (*fn_ptr) (int, int);
   int res;
   fn_ptr = add;
   res = fn_ptr(2, 3);  /* incorrectIncorrect */
   /* ... */
   return 0;
}

Compliant Solution (Function Pointers)

To correct this example, the declaration of fn_ptr is changed to accept three arguments.:

int add(int x, int y, int z) {
   return x + y + z;
}

int main(int argc, char *argv[]) {
   int (*fn_ptr) (int, int, int) ;
   int res;
   fn_ptr = add;
   res = fn_ptr(2, 3, 4);
   /* ... */
   return 0;
}

Risk Assessment

Failing to include type information for function declarators can result in unexpected or unintended program behavior.

Automated Detection

...

Tool	Version	Checker	Description
Astrée	Include Page Astrée_V Astrée_V	function-prototype implicit-function-declaration	Partially checked
Axivion Bauhaus Suite	Include Page Axivion Bauhaus Suite_V Axivion Bauhaus Suite_V	CertC-DCL07
CodeSonar	Include Page CodeSonar_V CodeSonar_V	LANG.FUNCS.PROT LANG.STRUCT.DECL.IMPT	Incomplete function prototype Implicit Type
ECLAIR	Include Page ECLAIR_V ECLAIR_V	CC2.DCL07	Fully implemented
GCC	Include Page GCC_V GCC_V		Can detect violation of this recommendation when the -Wstrict-prototypes flag is used
Helix QAC	Include Page Helix QAC_V Helix QAC_V	C1304, C2050, C3331, C3335, C3408, C3450
Klocwork	Include Page Klocwork_V Klocwork_V	MISRA.FUNC.PROT_FORM.KR.2012 MISRA.FUNC.NOPROT.DEF MISRA.CAST.FUNC_PTR.2012
LDRA tool suite	Include Page LDRA_V LDRA_V	21 S 135 S 170 S	Fully implemented
PC-lint Plus	Include Page PC-lint Plus_V PC-lint Plus_V	718, 746, 936, 9074	Fully supported
Polyspace Bug Finder	Include Page Polyspace Bug Finder_V Polyspace Bug Finder_V	CERT C: Rec. DCL07-C	Checks for: Cast between function pointers with different types Function declared implicitly. Rec. fully covered.
RuleChecker	Include Page RuleChecker_V RuleChecker_V	function-prototype implicit-function-declaration	Partially checked
SonarQube C/C++ Plugin	Include Page SonarQube C/C++ Plugin_V SonarQube C/C++ Plugin_V	S819, S930

Related Vulnerabilities

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

References

...

Related Guidelines

Bibliography

...

...

...

...

...

DCL06-A. Use meaningful symbolic constants to represent literal values in program logic      02. Declarations and Initialization (DCL)       DCL08-A. Properly encode relationships in constant definitionsImage Added Image Added Image Added