Move away from integral casts in xorbuf

[noloader]

xorbuf in misc.cpp has code to perform xor's on arbitrary buffers. For example:

void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)
{
    size_t i=0;
    if (IsAligned<word32>(output) && IsAligned<word32>(input) && IsAligned<word32>(mask))
    {
        if (IsAligned<word64>(output) && IsAligned<word64>(input) && IsAligned<word64>(mask))
        {
            for (i=0; i<count/8; i++)
                ((word64*)(void*)output)[i] = ((word64*)(void*)input)[i] ^ ((word64*)(void*)mask)[i];
            count -= 8*i;
            if (!count)
                return;
            output += 8*i;
            input += 8*i;
            mask += 8*i;
        }

        for (i=0; i<count/4; i++)
            ((word32*)(void*)output)[i] = ((word32*)(void*)input)[i] ^ ((word32*)(void*)mask)[i];
        count -= 4*i;
        if (!count)
            return;
        output += 4*i;
        input += 4*i;
        mask += 4*i;
    }

    for (i=0; i<count; i++)
        output[i] = input[i] ^ mask[i];
}

The casting is kind of shady nowadays. It could draw the ire of the compiler and earn us a demerit.

In a simpler form, this is closer to what we should be doing. It avoids the cast and honors alignment. Compilers nowadays will know when they can elide the memcpy and simply perform the xor.

void xorbuf(byte *output, const byte *input, const byte *mask, size_t count)
{
    while (count >= 4)
    {
        word32 b, m, r;
        memcpy(&b, input, 4); memcpy(&m, mask, 4);

        r = b ^ m;
        memcpy(output, &r, 4);

        output += 4; input += 4; mask += 4; count -= 4;
    }

    for (size_t i=0; i<count; i++)
        output[i] = input[i] ^ mask[i];
}

In fact, we can add some architectural speed-ups to make things run even faster without the casting. The code below runs 0.1 cpb to 0.4 cpb faster on x86_64. An x86_64 machine will enable the __SSE2__ code path without arch options.

void xorbuf(byte *buf, const byte *mask, size_t count)
{
#if defined(__AVX__)
    while (count >= 32)
    {
        __m256i b = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(buf));
        __m256i m = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(mask));
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(buf), _mm256_castps_si256(
            _mm256_xor_ps(_mm256_castsi256_ps(b), _mm256_castsi256_ps(m))));
        buf += 32; mask += 32; count -= 32;
    }
#endif
#if defined(__SSE2__)
    while (count >= 16)
    {
        __m128i b = _mm_loadu_si128(reinterpret_cast<const __m128i*>(buf));
        __m128i m = _mm_loadu_si128(reinterpret_cast<const __m128i*>(mask));
        _mm_storeu_si128(reinterpret_cast<__m128i*>(buf), _mm_castps_si128(
            _mm_xor_ps(_mm_castsi128_ps(b), _mm_castsi128_ps(m))));
        buf += 16; mask += 16; count -= 16;
    }

    if (count == 0) return;
#endif

    while (count >= 4)
    {
        word32 r, b, m;
        memcpy(&b, buf, 4); memcpy(&m, mask, 4);

        r = b ^ m;
        memcpy(buf, &r, 4);

        buf += 4; mask += 4; count -= 4;
    }

    for (size_t i=0; i<count; i++)
        buf[i] ^= mask[i];
}

This bug report will track the cut-over.