Function pointer cast to different signature

by

By the C specification, casting a function pointer results in undefined behavior. In fact, for a while, GCC 4.3 prereleases would return NULL whenever you casted a function pointer, perfectly valid by the spec, but they backed out that change before release because it broke lots of programs.

Assuming GCC continues doing what it does now, it will work fine with the default x86 calling convention (and most calling conventions on most architectures), but I wouldn’t depend on it. Testing the function pointer against NULL at every callsite isn’t much more expensive than a function call. If you really want, you may write a macro:

#define CALL_MAYBE(func, args...) do {if (func) (func)(## args);} while (0)

Or you could have a different dummy function for every signature, but I can understand that you’d like to avoid that.

Edit

Charles Bailey called me out on this, so I went and looked up the details (instead of relying on my holey memory). The C specification says

766 A pointer to a function of one type may be converted to a pointer to a function of another type and back again;
767 the result shall compare equal to the original pointer.
768 If a converted pointer is used to call a function whose type is not compatible with the pointed-to type, the behavior is undefined.

and GCC 4.2 prereleases (this was settled way before 4.3) was following these rules: the cast of a function pointer did not result in NULL, as I wrote, but attempting to call a function through a incompatible type, i.e.

func = (cb_t)nothing;
func(1);

from your example, would result in an abort. They changed back to the 4.1 behavior (allow but warn), partly because this change broke OpenSSL, but OpenSSL has been fixed in the meantime, and this is undefined behavior which the compiler is free to change at any time.

OpenSSL was only casting functions pointers to other function types taking and returning the same number of values of the same exact sizes, and this (assuming you’re not dealing with floating-point) happens to be safe across all the platforms and calling conventions I know of. However, anything else is potentially unsafe.

More Related Contents:

  1. What is pointer to string in C?
  2. What is the output of the following code in C? [closed]
  3. Incorrect result in c code
  4. whats the difference between dynamic memory allocation and normal memory allocation?
  5. pointer to string concept in c [closed]
  6. Why is the asterisk before the variable name, rather than after the type?
  7. What’s the difference between a VLA and dynamic memory allocation via malloc?
  8. Why does this implementation of offsetof() work?
  9. Why can’t I cast a function pointer to (void *)?
  10. Constant pointer vs Pointer to constant [duplicate]
  11. Can the size of pointers vary between data and function pointers?
  12. Function to dynamically allocate matrix
  13. In C, what is the correct syntax for declaring pointers?
  14. C typedef of pointer to structure
  15. Pointers – Difference between Array and Pointer
  16. Are “malloc(sizeof(struct a *))” and “malloc(sizeof(struct a))” the same?
  17. C – SizeOf Pointers
  18. Swapping pointers in C (char, int)
  19. What is double star (eg. NSError **)?
  20. Where in memory are string literals ? stack / heap? [duplicate]
  21. How to include a dynamic array INSIDE a struct in C?
  22. How can I return a character array from a function in C?
  23. C difference between *[] and **
  24. Difference between *ptr[10] and (*ptr)[10]
  25. How are we able to access the pointer after deallocating the memory?
  26. When is it valid to access a pointer to a “dead” object?
  27. How to check if a pointer is freed already in C?
  28. Returning a struct pointer
  29. Casting void pointers
  30. Cast T[][] to T*

Leave a Comment