[OT] compiler optimisations

[John Colvin via Digitalmars-d]

On Thursday, 23 April 2015 at 12:37:12 UTC, Ola Fosheim Grøstad 
wrote:
> On Thursday, 23 April 2015 at 08:56:38 UTC, rumbu wrote:
>> I think because of the potential overflow in a * 3 (if we 
>> ignore the a < 5 condition). To optimize this, a compiler must 
>> figure out that there is no overflow for any a < 5.
>
> Yes, it is because of modular artithmetics which is a D design 
> flaw. In C++ this only applies to unsigned integers, signed 
> integers are monothonic in C++. I think Rust uses non-modular 
> for both and Ada allows you to specify it.
>
> Compiled using ICC:
>
> int foo(int a)
> {
> 	if (a > 5)
> 		return (a * 3) / 3;
> 	else
> 		return 0;
> }
>
> yields:
>
>         xorl      %edx, %edx
>         cmpl      $5, %edi
>         cmovle    %edx, %edi
>         movl      %edi, %eax
>         ret
>
> ---------------------------------
>
> int foo(unsigned int a)
> {
> 	if (a > 5)
> 		return (a * 3) / 3;
> 	else
> 		return 0;
> }
>
> yields:
>
>         cmpl      $5, %edi
>         jbe       ..B1.3
>         movl      $-1431655765, %eax
>         lea       (%rdi,%rdi,2), %ecx
>         mull      %ecx
>         shrl      $1, %edx
>         movl      %edx, %eax
>         ret
> ..B1.3:
>         xorl      %eax, %eax
>         ret

Just to confirm this, all C compilers I tried were able to use 
the undefined behaviour of signed overflow to avoid the 
multiplication. D compilers of course do not do this, as signed 
overflow is defined.

Nonetheless, I maintain that the compiler should be able to 
propagate the value range of a and perform the optimisation 
regardless.