Change Log: 2.077.0

Symbols with extern(D) linkage are now mangled using back references to types and identifiers if these occur more than once in the mangled name as emitted before. This reduces symbol length, especially with chained expressions of templated functions with Voldemort return types. For example, the average symbol length of the 127000+ symbols created by a phobos unittest build is reduced by a factor of about 3, while the longest symbol shrinks from 416133 to 1142 characters.

See details in the ABI specification.

The compiler used to insert an assert(this, "null this"); at the start of constructors & destructors. To trigger these asserts one needed to construct or destruct an aggregate at the null memory location. This would crash upon any data member access, which is required for a constructor or destructor to do anything useful.

The dmd reference compiler now deterministically produces identical binaries for a given source code and configuration, thus allowing third parties to verify that distributed binaries indeed originate from specified source code.

This guarantee only applies when the same compiler version and configuration is used. Also values of the non-deterministic lexer tokens __DATE__, __TIME__, and __TIMESTAMP__ must not end up in the binary.

See reproducible-builds.org for further information.

core.atomic.atomicLoad used to strip the shared qualifier off too eagerly. When an aggregate type has a "head" and a "tail", connected by an indirection, then atomicLoad used to strip shared off the tail. That was a bug (Bugzilla 16230). atomicLoad only loads the head. The tail remains in shared memory, and must keep the shared qualifier.

When loading a struct that contains indirections, atomicLoad now returns a wrapper that provides getters which return properly typed values.

When loading a class reference, atomicLoad now leaves the shared qualifier on.

Example:

class C { int value; }
shared C shc = new C;

struct S { int head; int* tailPointer; }
shared int tail = 1;
auto shs = shared S(2, &tail);

void main()
{
    import core.atomic : atomicLoad, atomicOp;

    // Loading a class reference:
    shared C c = atomicLoad(shc);
    // c itself is not actually shared. It's safe to copy it non-atomically:
    shared C c2 = c; // ok
    // c's fields are still shared and need to be loaded atomically:
    int v = atomicLoad(c.value);

    // Loading a struct that has an indirection:
    auto s = atomicLoad(shs);
    // The struct's head has been copied and can be modified non-atomically:
    ++s.head;
    // The tail is still shared and needs to be handled atomically:
    shared(int)* t = s.tailPointer;
    atomicOp!"+="(*t, 1);
}

Array operations have been converted from dedicated assembly routines for some array operations to a generic template implementation for all array operations. This provides huge performance increases (2-4x higher throughput) for array operations that were not previously vectorized. Furthermore the implementation makes better use of vectorization even for short arrays to heavily reduce latency for some operations (up to 4x).

For GDC/LDC the implementation relies on auto-vectorization, for DMD the implementation performs the vectorization itself. Support for vector operations with DMD is determined statically (-march=native, -march=avx2) to avoid binary bloat and the small test overhead. DMD enables SSE2 for 64-bit targets by default.

Also see druntime#1891

Note: The implementation no longer weakens floating point divisions (e.g. ary[] / scalar) to multiplication (ary[] * (1.0 / scalar)) as that may reduce precision. To preserve the higher performance of float multiplication when loss of precision is acceptable, use either -ffast-math with GDC/LDC or manually rewrite your code to multiply by (1.0 / scalar) for DMD.