Fix issue 19905 Floating point .init should be bitwise identical to .nan

[thewilsonator]

See also #7568 in particular #7568 (comment)

Walter wrote:
They should have the same bit patterns. We tried to make .init a signalling nan, but this was a complete failure. .init and .nan should both be a quiet nan
Because a signalling nan converts to a quiet nan when used. The problem was nobody could come up with a consistent definition of "used".

[thewilsonator]

One last vestige is

dmd/src/dmd/root/longdouble.d

Line 86 in 2457038

align(2) ulong mantissa = 0xC000000000000001UL; // default to snan

which looks to me wrong unless I'm reading https://www.topcoder.com/community/competitive-programming/tutorials/representation-of-integers-and-reals-section-2/ (subsection Summary of all possible values) since it has (at least) the top and bottom bits sets (which means distinction between MSB and LSB is moot).

[rainers]

which looks to me wrong

Yeah, that looks dubious. I don't remember well but I think we settled on to use qnan throughout. This one is a qnan, so the comment is wrong.

These look dubious, too, the highest bit should be used to set signalling/quiet:

dmd/src/dmd/root/longdouble.d

Lines 663 to 664 in 2457038

	longdouble_soft ld_qnan = longdouble_soft(0xC000000000000000UL, 0x7fff);
	longdouble_soft ld_snan = longdouble_soft(0xC000000000000001UL, 0x7fff);

[thewilsonator]

Yeah, that looks dubious

Good I'm not crazy then.

I don't remember well but I think we settled on to use qnan throughout

#7568 (comment)

These look dubious, too,

If we go through with this then I think we can get rid of snan completely.

[rainers]

I wonder whether problematic values might stick from bad nans in the host compiler as they are more or less reused. A test with an explicit check of the bit patterns would be nice.

[dlang-bot]

Thanks for your pull request and interest in making D better, @thewilsonator! We are looking forward to reviewing it, and you should be hearing from a maintainer soon.
Please verify that your PR follows this checklist:

• My PR is fully covered with tests (you can see the annotated coverage diff directly on GitHub with CodeCov's browser extension
• My PR is as minimal as possible (smaller, focused PRs are easier to review than big ones)
• I have provided a detailed rationale explaining my changes
• New or modified functions have Ddoc comments (with Params: and Returns:)

Please see CONTRIBUTING.md for more information.

---

If you have addressed all reviews or aren't sure how to proceed, don't hesitate to ping us with a simple comment.

Bugzilla references

Auto-close	Bugzilla	Severity	Description
✓	19905	minor	Floating point .init should be bitwise identical to .nan

Testing this PR locally

If you don't have a local development environment setup, you can use Digger to test this PR:

dub fetch digger
dub run digger -- build "master + dmd#9897"

[thewilsonator]

Added a test, lets find out.

[thewilsonator]

The spec apparently already says that double.init is double.nan.

I think this is good to go.

[thewilsonator]

This blocks #7568

[rainers]

Added a test, lets find out.

Thanks, looks good now. I was thinking about a more explicit and extensive test, though, e.g.

import core.stdc.stdio;

T byCTFE(T)()
{
    T x;
    return x;
}

void printNaN(T)(T x)
{
    ubyte[] px = cast(ubyte[])((&x)[0..1]);

    printf(T.stringof.ptr);
    printf(".nan = 0x");
    foreach_reverse(p; 0..T.sizeof)
        printf("%02x", px[p]);
    printf(" mantissa=%d\n", T.mant_dig);
}

bool bittst(ubyte[] ba, uint pos)
{
    uint mask = 1 << (pos % 8);
    version(LittleEndian)
        return (ba[pos / 8] & mask) != 0;
    else
        return (ba[$ - 1 - pos / 8] & mask) != 0;
}

void test(T)()
{
    T a = T.init, b = T.nan;
    printNaN(a);
    ubyte[] pa = cast(ubyte[])((&a)[0..1]);
    ubyte[] pb = cast(ubyte[])((&b)[0..1]);
    assert(pa[] == pb[]);
    
    enum c = byCTFE!T();
    a = c;
    assert(pa[] == pb[]);
    
    // the highest 2 bits of the mantissa should be set, everythng else zero
    assert(bittst(pa, T.mant_dig - 1));
    assert(bittst(pa, T.mant_dig - 2));
    foreach(p; 0..T.mant_dig - 2)
        assert(!bittst(pa, p));
}

void main()
{
    test!float();
    test!double();
    test!real();
}

It should better be merged with some related test files, runnable/nan.d would be a good candidate.

[thewilsonator]

Applied that test.

[thewilsonator]

@rainers I think this is good to go.

[rainers]

Applied that test.

Thanks. Sorry for the delay.

[thewilsonator]

No problems.