This paper focuses on the nonnull GCC attribute as described in the manual of GCC. This attribute specifies that some function parameters should be non-null pointers.  When  the compiler optimizations are activated, this can lead to unexpected results.

The declaration:

extern void *my_memcpy (void *dest, const void *src, size_t len)
          	__attribute__((nonnull (1, 2)));

causes the compiler to check that, in calls to my_memcpy(), arguments dest and src are non-null. If the compiler determines that a null pointer is passed in an argument slot marked as non-null, and the -Wnonnull or -Wall option is enabled, a warning is issued.

Here is a C source file called example.c using the nonnull GCC attribute:

#include <stdio.h>


extern int func(void *ptr)
  __attribute__((nonnull(1)));


int func(void *ptr)
{

  if (!ptr)
  {
    printf("NULL\n");
    return -1;
  }

  printf("!NULL\n");

  return 0;
}


int main(int ac, char *av[])
{

  func(NULL);

  return 0;
}

In the main() function, the function func() is passed NULL.

Without any special option passed on the GCC command line, the compiler does not warn:

$ gcc example.c
$ ./a.out
NULL

With the -Wall option, the compiler displays a warning:

$ gcc example.c -Wall
example.c: In function ~main~:
example.c:26:3: warning: null argument where non-null required (argument 1) [-Wnonnull]
$ ./a.out
NULL

When NULL is passed implicitely, the compiler does not warn:

#include <stdio.h>


extern int func(void *ptr)
  __attribute__((nonnull(1)));


int func(void *ptr)
{

  if (!ptr)
  {
    printf("NULL\n");
    return -1;
  }

  printf("!NULL\n");

  return 0;
}


int main(int ac, char *av[])
{
void *p = NULL;

  func(p);

  return 0;
}

$ gcc example.c -Wall
$ ./a.out
NULL

The GCC manual specifies that "The compiler may also choose to make optimizations based on the knowledge that certain function arguments will not be null". This can be pointed out with the following example :

#include <stdio.h>


extern int func(void *ptr)
  __attribute__((nonnull(1)));


int func(void *ptr)
{

  if (!ptr)
  {
    printf("NULL\n");
    return -1;
  }

  printf("!NULL\n");

  return 0;
}


int main(int ac, char *av[])
{
void *p = NULL;

  func(p);

  return 0;
}

$ gcc example.c -Wall -O2
$ ./a.out
!NULL

The display of "!NULL" instead of "NULL" shows that the optimizations of the compiler removed the code which checks the value of ptr argument.  In other words, the func() function has been changed as if it was written like this:

int func(void *ptr)
{

  if (!ptr)
  {
    printf("NULL\n");
    return -1;
  }

  printf("!NULL\n");

  return 0;
}

The following shows the assembly code of func() without and with optimization:

The author is an engineer in computer sciences located in France. He can be contacted here.