Undoc'd Feature?

[jte]

(07-17-2022 01:05 PM)Wes Loewer Wrote:  ⋮
It does not seem to be an optimization issue. Even without optimizations turned on, the compiler gives the same results.

Here’s a simple, intentionally undefined example that indicates what each compiler is probably doing.

Code:

a = 5;
a = 1000*a++ + 100*a++ + 10*a++;  // undefined expression.

Note: Since this is undefined, there is no guarantee that the results are indicative of the results a compiler would produce in a defined case, but it does suggest what a compiler might be doing. That said, here are some results:

gcc/clang/intel all print 5670
ms prints 5553
⋮

As an additional data point, I thought I’d try an Intel compiler (ICC 2021.5.0, optimizations on) on the following function:

Code:

int Wes2(int a)
{
a = 5;
a = 1000 * a++ + 100 * a++ + 10 * a++;
return a;
}

I got the following as output:

Code:

Wes2(int):
        mov       eax, 5553
        ret

I thought I’d also try the following, slightly different, function:

Code:

int Wes3(int &a)
{
a = 5;
a = 1000 * a++ + 100 * a++ + 10 * a++;
return a;
}

This slightly different function has the compiler producing the following, noticably distinct, output:

Code:

Wes3(int&):
        mov       eax, 6
        mov       DWORD PTR [rdi], 6
        ret

(Without optimization, for this last function, the compiler is producing code that increments three distinct temporaries by one and then assigning, as a final value for “a”, one of those three incremented-once temporaries, post increment.)

When one goes rooting around with undefined behaviour, one can certainly feel the hidden contours of the magic machinery behind the scenes. That said, after seeing the above, I tried a few other similar functions and there does seem to be some issues with the Intel compiler’s handling of assignment operations post-C++17. (Even with a command-line option given to specify the version of C++ wanted.)