erl_hash

#include "murmur3.h"

// Based on:
// https://raw.githubusercontent.com/VoltDB/voltdb/master/third_party/cpp/murmur3/MurmurHash3.cpp
// Preserves the legacy 32-bit API while exposing the full MurmurHash3 x64 128-bit hash.

#define FORCE_INLINE inline __attribute__((always_inline))
#define ROTL64(x,y) rotl64(x,y)
#define BIG_CONSTANT(x) (x##LLU)

namespace {

FORCE_INLINE uint64_t rotl64(uint64_t x, int8_t r)
{
    return (x << r) | (x >> (64 - r));
}

FORCE_INLINE uint64_t getblock(const uint64_t* p, int i)
{
    return p[i];
}

FORCE_INLINE uint64_t fmix(uint64_t k)
{
    k ^= k >> 33;
    k *= BIG_CONSTANT(0xff51afd7ed558ccd);
    k ^= k >> 33;
    k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
    k ^= k >> 33;
    return k;
}

FORCE_INLINE void murmur3_x64_128_core(const void* key, int len, uint32_t seed, uint64_t* h1_out, uint64_t* h2_out)
{
    const uint8_t* data = static_cast<const uint8_t*>(key);
    const int nblocks = len / 16;

    uint64_t h1 = seed;
    uint64_t h2 = seed;

    const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
    const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);

    const uint64_t* blocks = reinterpret_cast<const uint64_t*>(data);

    for (int i = 0; i < nblocks; i++)
    {
        uint64_t k1 = getblock(blocks, i * 2 + 0);
        uint64_t k2 = getblock(blocks, i * 2 + 1);

        k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
        h1 = ROTL64(h1, 27); h1 += h2; h1 = h1 * 5 + 0x52dce729;

        k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
        h2 = ROTL64(h2, 31); h2 += h1; h2 = h2 * 5 + 0x38495ab5;
    }

    const uint8_t* tail = data + nblocks * 16;

    uint64_t k1 = 0;
    uint64_t k2 = 0;

    switch (len & 15)
    {
        case 15: k2 ^= static_cast<uint64_t>(tail[14]) << 48;
        case 14: k2 ^= static_cast<uint64_t>(tail[13]) << 40;
        case 13: k2 ^= static_cast<uint64_t>(tail[12]) << 32;
        case 12: k2 ^= static_cast<uint64_t>(tail[11]) << 24;
        case 11: k2 ^= static_cast<uint64_t>(tail[10]) << 16;
        case 10: k2 ^= static_cast<uint64_t>(tail[9])  << 8;
        case  9: k2 ^= static_cast<uint64_t>(tail[8]);
                 k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
        case  8: k1 ^= static_cast<uint64_t>(tail[7]) << 56;
        case  7: k1 ^= static_cast<uint64_t>(tail[6]) << 48;
        case  6: k1 ^= static_cast<uint64_t>(tail[5]) << 40;
        case  5: k1 ^= static_cast<uint64_t>(tail[4]) << 32;
        case  4: k1 ^= static_cast<uint64_t>(tail[3]) << 24;
        case  3: k1 ^= static_cast<uint64_t>(tail[2]) << 16;
        case  2: k1 ^= static_cast<uint64_t>(tail[1]) << 8;
        case  1: k1 ^= static_cast<uint64_t>(tail[0]);
                 k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
    }

    h1 ^= len;
    h2 ^= len;

    h1 += h2;
    h2 += h1;

    h1 = fmix(h1);
    h2 = fmix(h2);

    h1 += h2;
    h2 += h1;

    *h1_out = h1;
    *h2_out = h2;
}

}

// Legacy API — Returns top 32 bits of h1

int32_t hash_murmur3_x64_128_legacy(const void* key, int len, uint32_t seed)
{
    uint64_t h1, h2;
    murmur3_x64_128_core(key, len, seed, &h1, &h2);
    return static_cast<int32_t>(h1 >> 32);
}

// New API — full 128-bit hash

murmur3_128_t hash_murmur3_x64_128(const void* key, int len, uint32_t seed)
{
    murmur3_128_t out;
    murmur3_x64_128_core(key, len, seed, &out.high, &out.low);
    return out;
}