xxhash.c File Reference

#include <stdlib.h>
#include <string.h>
#include "xxhash.h"

Include dependency graph for xxhash.c:

Go to the source code of this file.

Macros
#define	XXH_FORCE_NATIVE_FORMAT   0
#define	XXH_FORCE_ALIGN_CHECK   1
#define	XXH_STATIC_LINKING_ONLY
#define	FORCE_INLINE   static
#define	XXH_GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)
#define	XXH_rotl32(x, r)
#define	XXH_rotl64(x, r)
#define	XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
#define	XXH_STATIC_ASSERT(c)
#define	XXH_get32bits(p)
#define	MEM_MODULE
#define	XXH_get64bits(p)

Typedefs
typedef unsigned char	BYTE
typedef unsigned short	U16
typedef unsigned int	U32
typedef unsigned long long	U64

Enumerations
enum	XXH_endianess { XXH_bigEndian =0 , XXH_littleEndian =1 }
enum	XXH_alignment { XXH_aligned , XXH_unaligned }

Functions
FORCE_INLINE U32	XXH_readLE32_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U32	XXH_readLE32 (const void *ptr, XXH_endianess endian)
XXH_PUBLIC_API unsigned	XXH_versionNumber (void)
FORCE_INLINE U32	XXH32_endian_align (const void *input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
XXH_PUBLIC_API unsigned int	XXH32 (const void *input, size_t len, unsigned int seed)
XXH_PUBLIC_API XXH32_state_t *	XXH32_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH32_freeState (XXH32_state_t *statePtr)
XXH_PUBLIC_API void	XXH32_copyState (XXH32_state_t *dstState, const XXH32_state_t *srcState)
XXH_PUBLIC_API XXH_errorcode	XXH32_reset (XXH32_state_t *statePtr, unsigned int seed)
FORCE_INLINE XXH_errorcode	XXH32_update_endian (XXH32_state_t *state, const void *input, size_t len, XXH_endianess endian)
XXH_PUBLIC_API XXH_errorcode	XXH32_update (XXH32_state_t *state_in, const void *input, size_t len)
FORCE_INLINE U32	XXH32_digest_endian (const XXH32_state_t *state, XXH_endianess endian)
XXH_PUBLIC_API unsigned int	XXH32_digest (const XXH32_state_t *state_in)
XXH_PUBLIC_API void	XXH32_canonicalFromHash (XXH32_canonical_t *dst, XXH32_hash_t hash)
XXH_PUBLIC_API XXH32_hash_t	XXH32_hashFromCanonical (const XXH32_canonical_t *src)
FORCE_INLINE U64	XXH_readLE64_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE U64	XXH_readLE64 (const void *ptr, XXH_endianess endian)
FORCE_INLINE U64	XXH64_endian_align (const void *input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
XXH_PUBLIC_API unsigned long long	XXH64 (const void *input, size_t len, unsigned long long seed)
XXH_PUBLIC_API XXH64_state_t *	XXH64_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH64_freeState (XXH64_state_t *statePtr)
XXH_PUBLIC_API void	XXH64_copyState (XXH64_state_t *dstState, const XXH64_state_t *srcState)
XXH_PUBLIC_API XXH_errorcode	XXH64_reset (XXH64_state_t *statePtr, unsigned long long seed)
FORCE_INLINE XXH_errorcode	XXH64_update_endian (XXH64_state_t *state, const void *input, size_t len, XXH_endianess endian)
XXH_PUBLIC_API XXH_errorcode	XXH64_update (XXH64_state_t *state_in, const void *input, size_t len)
FORCE_INLINE U64	XXH64_digest_endian (const XXH64_state_t *state, XXH_endianess endian)
XXH_PUBLIC_API unsigned long long	XXH64_digest (const XXH64_state_t *state_in)
XXH_PUBLIC_API void	XXH64_canonicalFromHash (XXH64_canonical_t *dst, XXH64_hash_t hash)
XXH_PUBLIC_API XXH64_hash_t	XXH64_hashFromCanonical (const XXH64_canonical_t *src)

Macro Definition Documentation

FORCE_INLINE

#define FORCE_INLINE   static

Definition at line 126 of file xxhash.c.

MEM_MODULE

#define MEM_MODULE

Definition at line 525 of file xxhash.c.

XXH_CPU_LITTLE_ENDIAN

#define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))

Definition at line 211 of file xxhash.c.

XXH_FORCE_ALIGN_CHECK

#define XXH_FORCE_ALIGN_CHECK   1

XXH_FORCE_ALIGN_CHECK : This is a minor performance trick, only useful with lots of very small keys. It means : check for aligned/unaligned input. The check costs one initial branch per hash; set it to 0 when the input is guaranteed to be aligned, or when alignment doesn't matter for performance.

Definition at line 91 of file xxhash.c.

XXH_FORCE_NATIVE_FORMAT

#define XXH_FORCE_NATIVE_FORMAT   0

XXH_FORCE_MEMORY_ACCESS : By default, access to unaligned memory is controlled by memcpy(), which is safe and portable. Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. The below switch allow to select different access method for improved performance. Method 0 (default) : use memcpy(). Safe and portable. Method 1 : __packed statement. It depends on compiler extension (ie, not portable). This method is safe if your compiler supports it, and generally as fast or faster than memcpy. Method 2 : direct access. This method doesn't depend on compiler but violate C standard. It can generate buggy code on targets which do not support unaligned memory accesses. But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) See http://stackoverflow.com/a/32095106/646947 for details. Prefer these methods in priority order (0 > 1 > 2)

XXH_ACCEPT_NULL_INPUT_POINTER : If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. By default, this option is disabled. To enable it, uncomment below define :

XXH_FORCE_NATIVE_FORMAT : By default, xxHash library provides endian-independent Hash values, based on little-endian convention. Results are therefore identical for little-endian and big-endian CPU. This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. Should endian-independence be of no importance for your application, you may set the #define below to 1, to improve speed for Big-endian CPU. This option has no impact on Little_Endian CPU.

Definition at line 77 of file xxhash.c.

XXH_GCC_VERSION

#define XXH_GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)

Definition at line 177 of file xxhash.c.

XXH_get32bits

#define XXH_get32bits

(

p

)

Value:

XXH_readLE32_align(p, endian, align)

XXH_get64bits

#define XXH_get64bits

(

p

)

Value:

XXH_readLE64_align(p, endian, align)

XXH_rotl32

#define XXH_rotl32	(		x,
			r )

Value:

((x << r) | (x >> (32 - r)))

Definition at line 184 of file xxhash.c.

XXH_rotl64

#define XXH_rotl64	(		x,
			r )

Value:

((x << r) | (x >> (64 - r)))

Definition at line 185 of file xxhash.c.

XXH_STATIC_ASSERT

#define XXH_STATIC_ASSERT

(

c

)

Value:

{ enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */

Definition at line 242 of file xxhash.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 108 of file xxhash.c.

Typedef Documentation

BYTE

typedef unsigned char BYTE

Definition at line 141 of file xxhash.c.

U16

typedef unsigned short U16

Definition at line 142 of file xxhash.c.

U32

typedef unsigned int U32

Definition at line 143 of file xxhash.c.

U64

typedef unsigned long long U64

Definition at line 530 of file xxhash.c.

Enumeration Type Documentation

XXH_alignment

enum XXH_alignment

Enumerator
XXH_aligned
XXH_unaligned

Definition at line 218 of file xxhash.c.

{ XXH_aligned, XXH_unaligned } XXH_alignment;

XXH_endianess

enum XXH_endianess

Enumerator
XXH_bigEndian
XXH_littleEndian

Definition at line 206 of file xxhash.c.

{ XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;

Function Documentation

XXH32()

XXH_PUBLIC_API unsigned int XXH32	(	const void *	input,
		size_t	length,
		unsigned int	seed )

XXH32() : Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input". The memory between input & input+length must be valid (allocated and read-accessible). "seed" can be used to alter the result predictably. Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s

Definition at line 320 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_state_t state;
    XXH32_reset(&state, seed);
    XXH32_update(&state, input, len);
    return XXH32_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

Here is the call graph for this function:

XXH32_canonicalFromHash()

XXH_PUBLIC_API void XXH32_canonicalFromHash	(	XXH32_canonical_t *	dst,
		XXH32_hash_t	hash )

Default XXH result types are basic unsigned 32 and 64 bits. The canonical representation follows human-readable write convention, aka big-endian (large digits first). These functions allow transformation of hash result into and from its canonical format. This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.

Definition at line 503 of file xxhash.c.

{
    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
    memcpy(dst, &hash, sizeof(*dst));
}

Here is the call graph for this function:

XXH32_copyState()

XXH_PUBLIC_API void XXH32_copyState	(	XXH32_state_t *	dstState,
		const XXH32_state_t *	srcState )

Definition at line 360 of file xxhash.c.

{
    memcpy(dstState, srcState, sizeof(*dstState));
}

Here is the call graph for this function:

XXH32_createState()

XXH_PUBLIC_API XXH32_state_t * XXH32_createState

(

void

)

Definition at line 350 of file xxhash.c.

{
    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
}

XXH32_digest()

XXH_PUBLIC_API unsigned int XXH32_digest

(

const XXH32_state_t *

state_in

)

Definition at line 484 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH32_digest_endian(state_in, XXH_bigEndian);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH32_digest_endian()

FORCE_INLINE U32 XXH32_digest_endian	(	const XXH32_state_t *	state,
		XXH_endianess	endian )

Definition at line 448 of file xxhash.c.

{
    const BYTE * p = (const BYTE*)state->mem32;
    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
    U32 h32;
 
    if (state->large_len) {
        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->v3 /* == seed */ + PRIME32_5;
    }
 
    h32 += state->total_len_32;
 
    while (p+4<=bEnd) {
        h32 += XXH_readLE32(p, endian) * PRIME32_3;
        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
        p+=4;
    }
 
    while (p<bEnd) {
        h32 += (*p) * PRIME32_5;
        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
        p++;
    }
 
    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;
 
    return h32;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH32_endian_align()

FORCE_INLINE U32 XXH32_endian_align	(	const void *	input,
		size_t	len,
		U32	seed,
		XXH_endianess	endian,
		XXH_alignment	align )

Definition at line 263 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* bEnd = p + len;
    U32 h32;
#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
 
#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
    if (p==NULL) {
        len=0;
        bEnd=p=(const BYTE*)(size_t)16;
    }
#endif
 
    if (len>=16) {
        const BYTE* const limit = bEnd - 16;
        U32 v1 = seed + PRIME32_1 + PRIME32_2;
        U32 v2 = seed + PRIME32_2;
        U32 v3 = seed + 0;
        U32 v4 = seed - PRIME32_1;
 
        do {
            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
        } while (p<=limit);
 
        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
    } else {
        h32  = seed + PRIME32_5;
    }
 
    h32 += (U32) len;
 
    while (p+4<=bEnd) {
        h32 += XXH_get32bits(p) * PRIME32_3;
        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
        p+=4;
    }
 
    while (p<bEnd) {
        h32 += (*p) * PRIME32_5;
        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
        p++;
    }
 
    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;
 
    return h32;
}

Here is the caller graph for this function:

XXH32_freeState()

XXH_PUBLIC_API XXH_errorcode XXH32_freeState

(

XXH32_state_t *

statePtr

)

Definition at line 354 of file xxhash.c.

{
    XXH_free(statePtr);
    return XXH_OK;
}

XXH32_hashFromCanonical()

XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical

(

const XXH32_canonical_t *

src

)

Definition at line 510 of file xxhash.c.

{
    return XXH_readBE32(src);
}

XXH32_reset()

XXH_PUBLIC_API XXH_errorcode XXH32_reset	(	XXH32_state_t *	statePtr,
		unsigned int	seed )

Definition at line 365 of file xxhash.c.

{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH32_update()

XXH_PUBLIC_API XXH_errorcode XXH32_update	(	XXH32_state_t *	state_in,
		const void *	input,
		size_t	len )

Definition at line 436 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH32_update_endian()

FORCE_INLINE XXH_errorcode XXH32_update_endian	(	XXH32_state_t *	state,
		const void *	input,
		size_t	len,
		XXH_endianess	endian )

Definition at line 378 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* const bEnd = p + len;
 
#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
    if (input==NULL) return XXH_ERROR;
#endif
 
    state->total_len_32 += (unsigned)len;
    state->large_len |= (len>=16) | (state->total_len_32>=16);
 
    if (state->memsize + len < 16)  {   /* fill in tmp buffer */
        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
        state->memsize += (unsigned)len;
        return XXH_OK;
    }
 
    if (state->memsize) {   /* some data left from previous update */
        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
        {   const U32* p32 = state->mem32;
            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
        }
        p += 16-state->memsize;
        state->memsize = 0;
    }
 
    if (p <= bEnd-16) {
        const BYTE* const limit = bEnd - 16;
        U32 v1 = state->v1;
        U32 v2 = state->v2;
        U32 v3 = state->v3;
        U32 v4 = state->v4;
 
        do {
            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
        } while (p<=limit);
 
        state->v1 = v1;
        state->v2 = v2;
        state->v3 = v3;
        state->v4 = v4;
    }
 
    if (p < bEnd) {
        XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
        state->memsize = (unsigned)(bEnd-p);
    }
 
    return XXH_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH64()

XXH_PUBLIC_API unsigned long long XXH64	(	const void *	input,
		size_t	length,
		unsigned long long	seed )

XXH64() : Calculate the 64-bits hash of sequence of length "len" stored at memory address "input". "seed" can be used to alter the result predictably. This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark).

Definition at line 692 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH64_state_t state;
    XXH64_reset(&state, seed);
    XXH64_update(&state, input, len);
    return XXH64_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

Here is the call graph for this function:

XXH64_canonicalFromHash()

XXH_PUBLIC_API void XXH64_canonicalFromHash	(	XXH64_canonical_t *	dst,
		XXH64_hash_t	hash )

Definition at line 876 of file xxhash.c.

{
    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
    memcpy(dst, &hash, sizeof(*dst));
}

Here is the call graph for this function:

XXH64_copyState()

XXH_PUBLIC_API void XXH64_copyState	(	XXH64_state_t *	dstState,
		const XXH64_state_t *	srcState )

Definition at line 730 of file xxhash.c.

{
    memcpy(dstState, srcState, sizeof(*dstState));
}

Here is the call graph for this function:

XXH64_createState()

XXH_PUBLIC_API XXH64_state_t * XXH64_createState

(

void

)

Definition at line 720 of file xxhash.c.

{
    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
}

XXH64_digest()

XXH_PUBLIC_API unsigned long long XXH64_digest

(

const XXH64_state_t *

state_in

)

Definition at line 863 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH64_digest_endian(state_in, XXH_bigEndian);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH64_digest_endian()

FORCE_INLINE U64 XXH64_digest_endian	(	const XXH64_state_t *	state,
		XXH_endianess	endian )

Definition at line 812 of file xxhash.c.

{
    const BYTE * p = (const BYTE*)state->mem64;
    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
    U64 h64;
 
    if (state->total_len >= 32) {
        U64 const v1 = state->v1;
        U64 const v2 = state->v2;
        U64 const v3 = state->v3;
        U64 const v4 = state->v4;
 
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
        h64 = XXH64_mergeRound(h64, v1);
        h64 = XXH64_mergeRound(h64, v2);
        h64 = XXH64_mergeRound(h64, v3);
        h64 = XXH64_mergeRound(h64, v4);
    } else {
        h64  = state->v3 + PRIME64_5;
    }
 
    h64 += (U64) state->total_len;
 
    while (p+8<=bEnd) {
        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
        h64 ^= k1;
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
        p+=8;
    }
 
    if (p+4<=bEnd) {
        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
        p+=4;
    }
 
    while (p<bEnd) {
        h64 ^= (*p) * PRIME64_5;
        h64  = XXH_rotl64(h64, 11) * PRIME64_1;
        p++;
    }
 
    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
    h64 ^= h64 >> 29;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
 
    return h64;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH64_endian_align()

FORCE_INLINE U64 XXH64_endian_align	(	const void *	input,
		size_t	len,
		U64	seed,
		XXH_endianess	endian,
		XXH_alignment	align )

Definition at line 623 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* bEnd = p + len;
    U64 h64;
#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
 
#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
    if (p==NULL) {
        len=0;
        bEnd=p=(const BYTE*)(size_t)32;
    }
#endif
 
    if (len>=32) {
        const BYTE* const limit = bEnd - 32;
        U64 v1 = seed + PRIME64_1 + PRIME64_2;
        U64 v2 = seed + PRIME64_2;
        U64 v3 = seed + 0;
        U64 v4 = seed - PRIME64_1;
 
        do {
            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
        } while (p<=limit);
 
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
        h64 = XXH64_mergeRound(h64, v1);
        h64 = XXH64_mergeRound(h64, v2);
        h64 = XXH64_mergeRound(h64, v3);
        h64 = XXH64_mergeRound(h64, v4);
 
    } else {
        h64  = seed + PRIME64_5;
    }
 
    h64 += (U64) len;
 
    while (p+8<=bEnd) {
        U64 const k1 = XXH64_round(0, XXH_get64bits(p));
        h64 ^= k1;
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
        p+=8;
    }
 
    if (p+4<=bEnd) {
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
        p+=4;
    }
 
    while (p<bEnd) {
        h64 ^= (*p) * PRIME64_5;
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
        p++;
    }
 
    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
    h64 ^= h64 >> 29;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
 
    return h64;
}

Here is the caller graph for this function:

XXH64_freeState()

XXH_PUBLIC_API XXH_errorcode XXH64_freeState

(

XXH64_state_t *

statePtr

)

Definition at line 724 of file xxhash.c.

{
    XXH_free(statePtr);
    return XXH_OK;
}

XXH64_hashFromCanonical()

XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical

(

const XXH64_canonical_t *

src

)

Definition at line 883 of file xxhash.c.

{
    return XXH_readBE64(src);
}

XXH64_reset()

XXH_PUBLIC_API XXH_errorcode XXH64_reset	(	XXH64_state_t *	statePtr,
		unsigned long long	seed )

Definition at line 735 of file xxhash.c.

{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH64_update()

XXH_PUBLIC_API XXH_errorcode XXH64_update	(	XXH64_state_t *	state_in,
		const void *	input,
		size_t	len )

Definition at line 802 of file xxhash.c.

{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
 
    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH64_update_endian()

FORCE_INLINE XXH_errorcode XXH64_update_endian	(	XXH64_state_t *	state,
		const void *	input,
		size_t	len,
		XXH_endianess	endian )

Definition at line 747 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* const bEnd = p + len;
 
#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
    if (input==NULL) return XXH_ERROR;
#endif
 
    state->total_len += len;
 
    if (state->memsize + len < 32) {  /* fill in tmp buffer */
        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
        state->memsize += (U32)len;
        return XXH_OK;
    }
 
    if (state->memsize) {   /* tmp buffer is full */
        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
        p += 32-state->memsize;
        state->memsize = 0;
    }
 
    if (p+32 <= bEnd) {
        const BYTE* const limit = bEnd - 32;
        U64 v1 = state->v1;
        U64 v2 = state->v2;
        U64 v3 = state->v3;
        U64 v4 = state->v4;
 
        do {
            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
        } while (p<=limit);
 
        state->v1 = v1;
        state->v2 = v2;
        state->v3 = v3;
        state->v4 = v4;
    }
 
    if (p < bEnd) {
        XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
        state->memsize = (unsigned)(bEnd-p);
    }
 
    return XXH_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH_readLE32()

FORCE_INLINE U32 XXH_readLE32	(	const void *	ptr,
		XXH_endianess	endian )

Definition at line 228 of file xxhash.c.

{
    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH_readLE32_align()

FORCE_INLINE U32 XXH_readLE32_align	(	const void *	ptr,
		XXH_endianess	endian,
		XXH_alignment	align )

Definition at line 220 of file xxhash.c.

{
    if (align==XXH_unaligned)
        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
    else
        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
}

Here is the caller graph for this function:

XXH_readLE64()

FORCE_INLINE U64 XXH_readLE64	(	const void *	ptr,
		XXH_endianess	endian )

Definition at line 588 of file xxhash.c.

{
    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XXH_readLE64_align()

FORCE_INLINE U64 XXH_readLE64_align	(	const void *	ptr,
		XXH_endianess	endian,
		XXH_alignment	align )

Definition at line 580 of file xxhash.c.

{
    if (align==XXH_unaligned)
        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
    else
        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
}

Here is the caller graph for this function:

XXH_versionNumber()

XXH_PUBLIC_API unsigned XXH_versionNumber

(

void

)

Definition at line 243 of file xxhash.c.

{ return XXH_VERSION_NUMBER; }