16

I am trying to create some macros that I can use to create my own unit testing library. My header file looks like this:

#ifndef _TEST_H_
#define _TEST_H_

#include <stdio.h>
#include "hehe_stack.h"

static hehe_stack* tests;
typedef int (*testfunc)();

#define test_init() tests = hehe_stack_init();
#define test_register(test) hehe_stack_push(tests, test);
#define test_info() fprintf(stdout, "running %s :: %s \n", __FILE__, __func__);
#define test_run() testfunc = (int (*)()) hehe_stack_pop(tests); testfunc(); return 0;

#endif

In each test .c file I want to push a number of function pointers into the tests stack and then pop each function pointer out of the stack and call it. My stack pop method returns a void pointer, and the function pointer that I am pushing onto it returns an int and takes no parameters. Is my syntax incorrect? I feel like I should be able to do this.

  • 4
    I cannot imagine any scenario where macros like these would make sense. – Lundin Dec 04 '12 at 07:31
  • @Lundin It would be better form to just implement them in a .c file? –  Dec 05 '12 at 03:36
  • 3
    Definitely. This is unreadable and will cause all kinds of bugs and trouble. And when (not if) the bugs appear, you will have a hard time debugging them, since debugging inside function-like macros is difficult. – Lundin Dec 05 '12 at 07:38

3 Answers3

34

The C99 standard does not allow to convert between pointers to data (in the standard, “objects or incomplete types” e.g. char* or void*) and pointers to functions.

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

One reason is that pointers to objects and pointers to functions do not have to be the same size. On an example architecture, the former can be 64-bit and the latter 32-bit.

You can cast from a pointer to a certain function type to a pointer to another function type, and this is the technique I recommend you use if you need to store function pointers in a data structure. Any function type will do. This means you cannot reuse a data structure intended for data pointers. You need to duplicate the data structure and change it to hold function pointers.

Do not forget to cast back to the proper function pointer type before calling, otherwise this is undefined behavior.

NOTE that, as pointed out by Andrew Mellinger, some compilers allow the conversion in each direction. C11's annex “J.5 Common extensions” lists:

J.5.7 Function pointer casts

1 A pointer to an object or to void may be cast to a pointer to a function, allowing data to be invoked as a function (6.5.4).

2 A pointer to a function may be cast to a pointer to an object or to void, allowing a function to be inspected or modified (for example, by a debugger) (6.5.4).

Some POSIX interfaces, such as dlsym(), also in effect mandate these conversions to be valid in the POSIX system's C compiler.

Pascal Cuoq
  • 79,187
  • 7
  • 161
  • 281
  • 2
    Does that code citation really have anything to do with casting between `void*` and function pointers though? – Jonathon Reinhart May 29 '15 at 12:50
  • @JonathonReinhart That clause lists exhaustively everything that you are allowed to do with a function pointer. I do not think the C standard explicitly says that converting a function pointer to an object pointer is forbidden, it simply does not list it as allowed, so the clause that says what a program is allowed to do with a function pointer is all I have to list. – Pascal Cuoq May 29 '15 at 13:08
  • @JonathonReinhart PDFs of drafts of the C standard are easy to come by, and my assertion can be disproved easily by citing the putative other clause in the C standard that would allow a program to do something else with a function pointer, so you are welcome to provide the reference to that hypothetical better choice of a clause. 4:2 contains the additional words “Undefined behavior is otherwise indicated in this International Standard by the words ‘‘undefined behavior’’ or by the omission of any explicit definition of behavior.”, if you think that's necessary. – Pascal Cuoq May 29 '15 at 13:10
  • 2
    @PascalCuoq : In the ISO/IEC 9899:201x draft from Dec 2, 2010 I found: "J.5.7 Function pointer casts 1 A pointer to an object or to void may be cast to a pointer to a function, allowing data to be invoked as a function (6.5.4). 2 A pointer to a function may be cast to a pointer to an object or to void, allowing a function to be inspected or modified (for example, by a debugger) (6.5.4)." – Andrew Mellinger May 23 '17 at 11:47
  • @AndrewMellinger I will incorporate this comment in the answer. – Pascal Cuoq May 23 '17 at 14:43
  • It may not explicitly allow fn_ptr<->data_ptr conversions, but it doesn't seem to disallow them or make them UB either. – Petr Skocik Apr 17 '19 at 07:08
7

You can do it, but you're not supposed to do it by accident, so the syntax is made especially awkward. One does not cast the function pointer, but a pointer to a function pointer, then assigns that.

#define test_run() *((void**)&testfunc) = hehe_stack_pop(tests); testfunc(); return 0;

This turns &testfunc into a pointer to a void*, then dereferences it and assigns the value of another void* to it, which is legal.

apmasell
  • 7,033
  • 19
  • 28
  • That doesn't compile for me. This ended up working: #define test_run() int (*testfunc)() = hehe_stack_pop(tests); testfunc(); return 0; –  Dec 04 '12 at 06:22
  • This assumes you have defined `testfunc` elsewhere. Defining a variable in the middle of a chunk of code will only work under newer versions of the C standard. – apmasell Dec 04 '12 at 14:26
  • Normally I try to avoid the things one isn't supposed to do, but I came across a case that actually required this cast on an architecture where I specifically know data pointers and function pointers are both 32-bit. [Example code](https://community.particle.io/t/dynamic-linking/30593/16?u=zachary) posted in the Particle community. – towynlin May 16 '17 at 09:05
0

The suggested code never compiles as you are not supposed to dereference a void * pointer (how could you? There is no type information about the particular pointer.)

The way cmotley suggests in his comment is the correct way to do this although I would recommend a little improvement for the sake of readability:

typedef int (*tTestFuncSignature)(void)
#define test_run() tTestFuncSignature testfunc = hehe_stack_pop(tests); testfunc();

or even to avoid hidden name clashes using this macro:

#define test_run() ((tTestFuncSignature)hehe_stack_pop(tests))();

Either way you have to make sure (e.g. by contract) you only got valid pointers in your stack or have to test the pointer first before invoking the function.

Edit: Corrected code formatting

junix
  • 3,161
  • 13
  • 27