C language most ignored compiler warning

If I had to choose the most ignored compiler warning that I have ever seen in my programming career, that would be for sure this one:

warning: implicit declaration of function <you name it>

Since the software builds and the results are correct, this warning seems to be kind of out of place, right?

Well, this is not the case if you deal with legacy projects based on the C89 version of the C standard, and I would say that it is rather a ticking time bomb waiting to explode when you least expect it (although easily disarmed by providing the missing function prototype!).

Introducing the implicit declaration of 'square'

Let's consider a trivial square() function that returns the square of an integer number provided as its input argument, but we only provide the function definition and no declaration for it.

The problem is shown in an exemplary manner in the following code adapted from King, K. N. (2008). C Programming: A Modern Approach, 2nd Edition (2nd ed.). W. W. Norton & Company:

#include <stdio.h>

int main(void)
{
  printf ("Square: %d\n", square(2));
  printf ("Square: %d\n", square(3));
  printf ("Square: %d\n", square(4));
  printf ("Square: %d\n", square(5));
  printf ("Square: %d\n", square(6));
  printf ("Square: %d\n", square(7));

  return 0;
}

int square(int n)
{
  return n * n;
}

When this program is built with a legacy C89 compiler, the compiler builds but issues the following warning:

main.c:5:27: warning: implicit declaration of function 'square'

When run the correct output is anyway produced:

Square: 4
Square: 9
Square: 16
Square: 25
Square: 36
Square: 49

There is no reason to worry, isn't it?

But what if a different user calls the function square() with an argument of type double instead of integer, like this:

#include <stdio.h>

int main(void)
{
  printf ("Square: %d\n", square(2.0));
  printf ("Square: %d\n", square(3.0));
  printf ("Square: %d\n", square(4.0));
  printf ("Square: %d\n", square(5.0));
  printf ("Square: %d\n", square(6.0));
  printf ("Square: %d\n", square(7.0));

  return 0;
}

int square(int n)
{
  return n * n;
}

This time the following incorrect output is produced:

Square: 1
Square: -1752610752
Square: -1752610752
Square: -1752610752
Square: -1752610752
Square: -1752610752

where undefined behaviour for all the function calls can be seen.

What happened?

When the compiler compiles the program, it encounters a function call, i.e. square(), without having found a prior prototype of the function itself, and implicitly declares one by applying paragraphs §3.3.2.2 (implicit declaration of function) and §3.5.2 (int type specifier) of the C89 standard:

3.3.2.2 Function calls

Constraints

....

Semantics

....

If the expression that denotes the called function has a type that does not include a prototype, the integral promotions are performed on each argument and arguments that have type float are promoted to double. These are called the default argument promotions.

....

3.5.2 Type specifiers

Syntax

type-specifier:

...

int

...

....

Constraints

Each list of type specifiers shall be one of the following sets; the type specifiers may occur in any order, possibly intermixed with the other declaration specifiers.

....

* int , signed , signed int , or no type specifiers

....

Let's see what this means when applied to the program above.

When the compiler encounters square(2.0), it will implicitly declare square() as

square(double);

where it applies default argument promotion on 2.0 with no effect (it is already a double literal and it is passed as such to square!) and the missing type specifier implies an integer as a return value. As a consequence, the function square() is called with the double 2.0 as argument, i.e. without performing a conversion to an integer, and since the function expects an integer argument, the net effect will be undefined behaviour and a meaningless integer value returned as a result, as seen above.

By providing the function prototype before the function call, the undefined behaviour is easily fixed:

#include <stdio.h>

/* required prototype for correct parameter conversion */
int square(int);

int main(void)
{
  /* without prototype, implicit declaration of square! */
  /* the compiler assumes int square(double n) */
  /* default argument promotions applies: n is passed as double
     and is not converted to int */

  printf ("Square: %d\n", square(2.0));
  printf ("Square: %d\n", square(3.0));
  printf ("Square: %d\n", square(4.0));
  printf ("Square: %d\n", square(5.0));
  printf ("Square: %d\n", square(6.0));
  printf ("Square: %d\n", square(7.0));

  return 0;
}

int square(int n)
{
 return n * n;
}

This time the produced output is the desired one:

Square: 4
Square: 9
Square: 16
Square: 25
Square: 36
Square: 49

Conclusion and references

Although trivial, the example above shows yet again the danger of ignoring compiler warnings, which might lead to undefined behaviour when unexpected or unintended inputs are provided. It shows as well how the identification of such issues depends on the knowledge of the subtleties of the programming language, in this case of how the compiler provides an implicit declaration itself, which might baffle even experienced professional programmers.

Thankfully, C99 compilers will throw a compilation error whenever a function call is found without a prior declaration or definition (no implicit function declarations), as well as whenever the return type of a function is omitted (no implicit integer return type).

Finally, the following references have been consulted for creating this post:

1. King, K. N. (2008). C Programming: A Modern Approach, 2nd Edition (2nd ed.). W. W. Norton & Company

2. C89 standard available online