Question

I’m trying to decide whether to implement certain operations as macros or as functions.

Say, just as an example, I have the following code in a header file:

extern int x_GLOB;
extern int y_GLOB;

#define min(x,y) ((x_GLOB = (x)) < (y_GLOB = (y))? x_GLOB : y_GLOB)

the intent is to have each single argument computed only once (min(x++,y++) would not cause any problem here).

The question is: do the two global variables pose any issue in terms of code re-entrancy or thread safeness?

I would say no but I’m not sure.

And what about:

#define min(x,y) ((x_GLOB = (x)), \
                  (y_GLOB = (y)), \
                  ((x_GLOB < y_GLOB) ? x_GLOB : y_GLOB)

would it be a differnt case?

Please note that the question is not “in general” but is related to the fact that those global variables are used just within that macro and for the evaluation of a single expression.

Anyway, looking at the answers below, I think I can summarize as follows:

• It’s not thread safe as nothing guarantees that a thread is suspended “in the middle” of the evaluation of an expression (as I hoped instead)

• The “state” those globals represent is, at least, the internal state of the “min” operation and preserving that state would, again at least, require to impose restrictions on how the function can be called (e.g. avoid min(min(1,2),min(3,1)).

I don’t think using non-portable constructs is a good idea either so I guess the only option is to stay on the safe side an implement those cases as regular functions.

Answer 1

Personally I don’t think this code is safe at all, even if we don’t consider multithreaded scenarios.

Take the following evaluation:

int a = min(min(1, 2), min(3, 4));

How will this expand properly and evaluate?

1. Evaluate min(1, 2) and assign value to x_GLOB (outer macro):
   • x_GLOB = 1
   • y_GLOB = 2
   • evaluate min, result is 1, assign to x_GLOB (for outer macro)
2. Evaluate min(3, 4) and assign value to y_GLOB (outer macro):
   • x_GLOB = 3 (uh-oh, 1 from the first expansion is now clobbered)
   • y_GLOB = 4
   • evaluate min, result is 3, assign to y_GLOB (for outer macro)
3. Evaluate min(a, b) where a is min(1, 2) and b is min(3, 4)
   • evaluate min of x_GLOB (which is 3) and y_GLOB (which is 3)
   • result of total evaluation is 3

Or am I missing something here?