Benchmark of D against other languages

[bearophile via Digitalmars-d]

Martin Nowak:

> GCC5 comes with a big announcement about devirtualization.
> https://www.gnu.org/software/gcc/gcc-5/changes.html#general

I have a small question. That page says:

"
A new set of built-in functions for arithmetics with overflow 
checking has been added: __builtin_add_overflow, 
__builtin_sub_overflow and __builtin_mul_overflow and for 
compatibility with clang also other variants. These builtins have 
two integral arguments (which don't need to have the same type), 
the arguments are extended to infinite precision signed type, +, 
- or * is performed on those, and the result is stored in an 
integer variable pointed to by the last argument. If the stored 
value is equal to the infinite precision result, the built-in 
functions return false, otherwise true. The type of the integer 
variable that will hold the result can be different from the 
types of the first two arguments. The following snippet 
demonstrates how this can be used in computing the size for the 
calloc function:

     void *
     calloc (size_t x, size_t y)
     {
       size_t sz;
       if (__builtin_mul_overflow (x, y, &sz))
         return NULL;
       void *ret = malloc (sz);
       if (ret) memset (res, 0, sz);
       return ret;
     }

On e.g. i?86 or x86-64 the above will result in a mul instruction 
followed by a jump on overflow.
"

Now both GCC and Clang have intrinsics to perform safe integral 
operations.

In recent versions of druntime/dmd there are functions to perform 
some safe integer operations. So is the API very well compatible 
with those intrinsics?

Bye,
bearophile