In C99, is f()+g() undefined or merely unspecified?

by

The expression f() + g() contains a minimum of 4 sequence points; one before the call to f() (after all zero of its arguments are evaluated); one before the call to g() (after all zero of its arguments are evaluated); one as the call to f() returns; and one as the call to g() returns. Further, the two sequence points associated with f() occur either both before or both after the two sequence points associated with g(). What you cannot tell is which order the sequence points will occur in – whether the f-points occur before the g-points or vice versa.

Even if the compiler inlined the code, it has to obey the ‘as if’ rule – the code must behave the same as if the functions were not interleaved. That limits the scope for damage (assuming a non-buggy compiler).

So the sequence in which f() and g() are evaluated is unspecified. But everything else is pretty clean.

In a comment, supercat asks:

I would expect function calls in the source code remain as sequence points even if a compiler decides on its own to inline them. Does that remain true of functions declared “inline”, or does the compiler get extra latitude?

I believe the ‘as if’ rule applies and the compiler doesn’t get extra latitude to omit sequence points because it uses an explicitly inline function. The main reason for thinking that (being too lazy to look for the exact wording in the standard) is that the compiler is allowed to inline or not inline a function according to its rules, but the behaviour of the program should not change (except for performance).

Also, what can be said about the sequencing of (a(),b()) + (c(),d())? Is it possible for c() and/or d() to execute between a() and b(), or for a() or b() to execute between c() and d()?

  • Clearly, a executes before b, and c executes before d. I believe it is possible for c and d to be executed between a and b, though it is fairly unlikely that it the compiler would generate the code like that; similarly, a and b could be executed between c and d. And although I used ‘and’ in ‘c and d’, that could be an ‘or’ – that is, any of these sequences of operation meet the constraints:

    • Definitely allowed
    • abcd
    • cdab
    • Possibly allowed (preserves a ≺ b, c ≺ d ordering)
    • acbd
    • acdb
    • cadb
    • cabd

     
    I believe that covers all possible sequences. See also the chat between Jonathan Leffler and AnArrayOfFunctions — the gist is that AnArrayOfFunctions does not think the ‘possibly allowed’ sequences are allowed at all.

If such a thing would be possible, that would imply a significant difference between inline functions and macros.

There are significant differences between inline functions and macros, but I don’t think the ordering in the expression is one of them. That is, any of the functions a, b, c or d could be replaced with a macro, and the same sequencing of the macro bodies could occur. The primary difference, it seems to me, is that with the inline functions, there are guaranteed sequence points at the function calls – as outlined in the main answer – as well as at the comma operators. With macros, you lose the function-related sequence points. (So, maybe that is a significant difference…) However, in so many ways the issue is rather like questions about how many angels can dance on the head of a pin – it isn’t very important in practice. If someone presented me with the expression (a(),b()) + (c(),d()) in a code review, I would tell them to rewrite the code to make it clear:

a();
c();
x = b() + d();

And that assumes there is no critical sequencing requirement on b() vs d().

More Related Contents:

  1. How to implement memmove in standard C without an intermediate copy?
  2. Why are these constructs using pre and post-increment undefined behavior?
  3. Unspecified, undefined and implementation defined behavior WIKI for C
  4. Sequence points and side effects in C
  5. function returns address of local variable, but it still compile in c, why?
  6. Undefined, unspecified and implementation-defined behavior
  7. Is type-punning through a union unspecified in C99, and has it become specified in C11?
  8. Is it possible to iterate over arguments in variadic macros?
  9. What does dot (.) mean in a struct initializer?
  10. What is the use of the `inline` keyword in C?
  11. C99 boolean data type?
  12. Is the behaviour of casting a negative double to unsigned int defined in the C standard? Different behaviour on ARM vs. x86
  13. Realistic usage of the C99 ‘restrict’ keyword?
  14. Flexible array member in C-structure
  15. 32 bit unsigned multiply on 64 bit causing undefined behavior?
  16. Why does this implementation of strlen() work?
  17. Can I omit return from main in C? [duplicate]
  18. C variable declarations after function heading in definition [duplicate]
  19. state machines tutorials [closed]
  20. Why does char* cause undefined behaviour while char[] doesn’t?
  21. Anonymous union within struct not in c99?
  22. C – function returning a pointer to a local variable
  23. When is it valid to access a pointer to a “dead” object?
  24. Is there a document describing how Clang handles excess floating-point precision?
  25. Is it Undefined Behaviour to cast away the constness of a function parameter?
  26. C – is an indeterminate value indeterminable?
  27. Does ctype.h still require unsigned char?
  28. Cast T[][] to T*
  29. Declaring an array of negative length
  30. Why are compound literals in C modifiable

Leave a Comment