xxhash.c File Reference

#include <stdlib.h>
#include <stddef.h>
#include <ntifs.h>
#include <ntddk.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_ALLOC_TAG   0x32485858
#define	XXH_STATIC_LINKING_ONLY
#define	INLINE_KEYWORD
#define	FORCE_INLINE_ATTR
#define	FORCE_INLINE_TEMPLATE   static INLINE_KEYWORD FORCE_INLINE_ATTR
#define	MEM_MODULE
#define	GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)
#define	XXH_rotl32(x, r)   ((x << r) | (x >> (32 - r)))
#define	XXH_rotl64(x, r)   ((x << r) | (x >> (64 - r)))
#define	XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
#define	XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; } /* use only *after* variable declarations */
#define	XXH_get32bits(p)   XXH_readLE32_align(p, endian, align)
#define	XXH_get64bits(p)   XXH_readLE64_align(p, endian, align)

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

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

Functions
static void *	XXH_malloc (size_t s)
static void	XXH_free (void *p)
static void *	XXH_memcpy (void *dest, const void *src, size_t size)
static U32	XXH_read32 (const void *memPtr)
static U64	XXH_read64 (const void *memPtr)
static U32	XXH_swap32 (U32 x)
static U64	XXH_swap64 (U64 x)
FORCE_INLINE_TEMPLATE U32	XXH_readLE32_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE_TEMPLATE U32	XXH_readLE32 (const void *ptr, XXH_endianess endian)
static U32	XXH_readBE32 (const void *ptr)
FORCE_INLINE_TEMPLATE U64	XXH_readLE64_align (const void *ptr, XXH_endianess endian, XXH_alignment align)
FORCE_INLINE_TEMPLATE U64	XXH_readLE64 (const void *ptr, XXH_endianess endian)
static U64	XXH_readBE64 (const void *ptr)
XXH_PUBLIC_API unsigned	XXH_versionNumber (void)
XXH_PUBLIC_API void	XXH32_copyState (XXH32_state_t *restrict dstState, const XXH32_state_t *restrict srcState)
XXH_PUBLIC_API void	XXH64_copyState (XXH64_state_t *restrict dstState, const XXH64_state_t *restrict srcState)
static U32	XXH32_round (U32 seed, U32 input)
FORCE_INLINE_TEMPLATE 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)
static U64	XXH64_round (U64 acc, U64 input)
static U64	XXH64_mergeRound (U64 acc, U64 val)
FORCE_INLINE_TEMPLATE 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 XXH32_state_t *	XXH32_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH32_freeState (XXH32_state_t *statePtr)
XXH_PUBLIC_API XXH64_state_t *	XXH64_createState (void)
XXH_PUBLIC_API XXH_errorcode	XXH64_freeState (XXH64_state_t *statePtr)
XXH_PUBLIC_API XXH_errorcode	XXH32_reset (XXH32_state_t *statePtr, unsigned int seed)
XXH_PUBLIC_API XXH_errorcode	XXH64_reset (XXH64_state_t *statePtr, unsigned long long seed)
FORCE_INLINE_TEMPLATE 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_TEMPLATE 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)
FORCE_INLINE_TEMPLATE 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_TEMPLATE 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	XXH32_canonicalFromHash (XXH32_canonical_t *dst, XXH32_hash_t hash)
XXH_PUBLIC_API void	XXH64_canonicalFromHash (XXH64_canonical_t *dst, XXH64_hash_t hash)
XXH_PUBLIC_API XXH32_hash_t	XXH32_hashFromCanonical (const XXH32_canonical_t *src)
XXH_PUBLIC_API XXH64_hash_t	XXH64_hashFromCanonical (const XXH64_canonical_t *src)

Variables
static const int	g_one = 1
static const U32	PRIME32_1 = 2654435761U
static const U32	PRIME32_2 = 2246822519U
static const U32	PRIME32_3 = 3266489917U
static const U32	PRIME32_4 = 668265263U
static const U32	PRIME32_5 = 374761393U
static const U64	PRIME64_1 = 11400714785074694791ULL
static const U64	PRIME64_2 = 14029467366897019727ULL
static const U64	PRIME64_3 = 1609587929392839161ULL
static const U64	PRIME64_4 = 9650029242287828579ULL
static const U64	PRIME64_5 = 2870177450012600261ULL

Macro Definition Documentation

FORCE_INLINE_ATTR

#define FORCE_INLINE_ATTR

Definition at line 169 of file xxhash.c.

FORCE_INLINE_TEMPLATE

#define FORCE_INLINE_TEMPLATE   static INLINE_KEYWORD FORCE_INLINE_ATTR

Definition at line 172 of file xxhash.c.

GCC_VERSION

#define GCC_VERSION   (__GNUC__ * 100 + __GNUC_MINOR__)

Definition at line 243 of file xxhash.c.

INLINE_KEYWORD

#define INLINE_KEYWORD

Definition at line 161 of file xxhash.c.

MEM_MODULE

#define MEM_MODULE

Definition at line 184 of file xxhash.c.

XXH_ALLOC_TAG

#define XXH_ALLOC_TAG   0x32485858

Definition at line 113 of file xxhash.c.

XXH_CPU_LITTLE_ENDIAN

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

Definition at line 290 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 to 0 when the input data is guaranteed to be aligned.

Definition at line 90 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-independant 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-independance 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_get32bits

#define XXH_get32bits

(

p

)

XXH_readLE32_align(p, endian, align)

XXH_get64bits

#define XXH_get64bits

(

p

)

XXH_readLE64_align(p, endian, align)

XXH_rotl32

#define XXH_rotl32	(		x,
			r
	)		((x << r) | (x >> (32 - r)))

Definition at line 250 of file xxhash.c.

XXH_rotl64

#define XXH_rotl64	(		x,
			r
	)		((x << r) | (x >> (64 - r)))

Definition at line 251 of file xxhash.c.

XXH_STATIC_ASSERT

#define XXH_STATIC_ASSERT

(

c

)

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

Definition at line 339 of file xxhash.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 150 of file xxhash.c.

Typedef Documentation

BYTE

typedef BYTE

Definition at line 193 of file xxhash.c.

S32

typedef signed int S32

Definition at line 196 of file xxhash.c.

U16

typedef unsigned short U16

Definition at line 194 of file xxhash.c.

U32

typedef unsigned int U32

Definition at line 195 of file xxhash.c.

U64

typedef unsigned long long U64

Definition at line 197 of file xxhash.c.

Enumeration Type Documentation

XXH_alignment

enum XXH_alignment

Enumerator
XXH_aligned
XXH_unaligned

Definition at line 297 of file xxhash.c.

{ XXH_aligned, XXH_unaligned } XXH_alignment;

XXH_endianess

enum XXH_endianess

Enumerator
XXH_bigEndian
XXH_littleEndian

Definition at line 285 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	len,
		unsigned int	seed
	)

Definition at line 443 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_CREATESTATE_STATIC(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
}

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 895 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));
}

XXH32_copyState()

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

Definition at line 363 of file xxhash.c.

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

XXH32_createState()

XXH_PUBLIC_API XXH32_state_t * XXH32_createState

(

void

)

State allocation, compatible with dynamic libraries

Definition at line 586 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 741 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);
}

Referenced by XXH32().

XXH32_digest_endian()

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

Definition at line 705 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;
}

Referenced by XXH32_digest().

XXH32_endian_align()

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

Definition at line 386 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;
}

Referenced by XXH32().

XXH32_freeState()

XXH_PUBLIC_API XXH_errorcode XXH32_freeState

(

XXH32_state_t *

statePtr

)

Definition at line 590 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 909 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 609 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;
}

Referenced by XXH32().

XXH32_round()

static U32 XXH32_round ( U32  seed, U32  input  )

static

Definition at line 378 of file xxhash.c.

{
    seed += input * PRIME32_2;
    seed  = XXH_rotl32(seed, 13);
    seed *= PRIME32_1;
    return seed;
}

Referenced by XXH32_endian_align(), and XXH32_update_endian().

XXH32_update()

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

Definition at line 693 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);
}

Referenced by XXH32().

XXH32_update_endian()

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

Definition at line 635 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)); p32++;
        }
        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;
}

Referenced by XXH32_update().

XXH64()

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

Definition at line 555 of file xxhash.c.

{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH64_CREATESTATE_STATIC(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
}

Referenced by calc_superblock_checksum(), calc_thread_main(), calc_tree_checksum(), check_sector_csum(), check_superblock_checksum(), check_tree_checksum(), get_sector_csum(), and get_tree_checksum().

XXH64_canonicalFromHash()

XXH_PUBLIC_API void XXH64_canonicalFromHash	(	XXH64_canonical_t *	dst,
		XXH64_hash_t	hash
	)

Definition at line 902 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));
}

XXH64_copyState()

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

Definition at line 368 of file xxhash.c.

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

XXH64_createState()

XXH_PUBLIC_API XXH64_state_t * XXH64_createState

(

void

)

Definition at line 596 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 874 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);
}

Referenced by XXH64(), ZSTD_decompressContinue(), ZSTD_decompressFrame(), and ZSTD_writeEpilogue().

XXH64_digest_endian()

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

Definition at line 822 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;
}

Referenced by XXH64_digest().

XXH64_endian_align()

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

Definition at line 486 of file xxhash.c.

{
    const BYTE* p = (const BYTE*)input;
    const BYTE* const 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;
}

Referenced by XXH64().

XXH64_freeState()

XXH_PUBLIC_API XXH_errorcode XXH64_freeState

(

XXH64_state_t *

statePtr

)

Definition at line 600 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 914 of file xxhash.c.

{
    return XXH_readBE64(src);
}

XXH64_mergeRound()

static U64 XXH64_mergeRound ( U64  acc, U64  val  )

static

Definition at line 478 of file xxhash.c.

{
    val  = XXH64_round(0, val);
    acc ^= val;
    acc  = acc * PRIME64_1 + PRIME64_4;
    return acc;
}

Referenced by XXH64_digest_endian(), and XXH64_endian_align().

XXH64_reset()

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

Definition at line 622 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;
}

Referenced by XXH64(), ZSTD_decodeFrameHeader(), and ZSTD_resetCCtx_internal().

XXH64_round()

static U64 XXH64_round ( U64  acc, U64  input  )

static

Definition at line 470 of file xxhash.c.

{
    acc += input * PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= PRIME64_1;
    return acc;
}

Referenced by XXH64_digest_endian(), XXH64_endian_align(), XXH64_mergeRound(), and XXH64_update_endian().

XXH64_update()

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

Definition at line 810 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);
}

Referenced by XXH64(), ZSTD_compress_frameChunk(), ZSTD_decompressContinue(), and ZSTD_decompressFrame().

XXH64_update_endian()

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

Definition at line 755 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;
}

Referenced by XXH64_update().

XXH_free()

static void XXH_free ( void *  p )

static

Definition at line 119 of file xxhash.c.

                              {
    ExFreePool(p);
}

Referenced by XXH32_freeState(), and XXH64_freeState().

XXH_malloc()

static void * XXH_malloc ( size_t  s )

static

Definition at line 115 of file xxhash.c.

                                  {
    return ExAllocatePoolWithTag(PagedPool, s, XXH_ALLOC_TAG);
}

Referenced by XXH32_createState(), and XXH64_createState().

XXH_memcpy()

static void * XXH_memcpy ( void *  dest, const void *  src, size_t  size  )

static

Definition at line 147 of file xxhash.c.

{ return memcpy(dest,src,size); }

Referenced by XXH32_update_endian(), and XXH64_update_endian().

XXH_read32()

static U32 XXH_read32 ( const void *  memPtr )

static

Definition at line 223 of file xxhash.c.

{
    U32 val;
    memcpy(&val, memPtr, sizeof(val));
    return val;
}

Referenced by XXH_readBE32(), and XXH_readLE32_align().

XXH_read64()

static U64 XXH_read64 ( const void *  memPtr )

static

Definition at line 230 of file xxhash.c.

{
    U64 val;
    memcpy(&val, memPtr, sizeof(val));
    return val;
}

Referenced by XXH_readBE64(), and XXH_readLE64_align().

XXH_readBE32()

static U32 XXH_readBE32 ( const void *  ptr )

static

Definition at line 312 of file xxhash.c.

{
    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
}

Referenced by XXH32_hashFromCanonical().

XXH_readBE64()

static U64 XXH_readBE64 ( const void *  ptr )

static

Definition at line 330 of file xxhash.c.

{
    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
}

Referenced by XXH64_hashFromCanonical().

XXH_readLE32()

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

Definition at line 307 of file xxhash.c.

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

Referenced by XXH32_digest_endian(), XXH32_update_endian(), and XXH64_digest_endian().

XXH_readLE32_align()

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

Definition at line 299 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);
}

Referenced by XXH_readLE32().

XXH_readLE64()

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

Definition at line 325 of file xxhash.c.

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

Referenced by XXH64_digest_endian(), and XXH64_update_endian().

XXH_readLE64_align()

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

Definition at line 317 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);
}

Referenced by XXH_readLE64().

XXH_swap32()

static U32 XXH_swap32 ( U32  x )

static

Definition at line 261 of file xxhash.c.

{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

Referenced by XXH32_canonicalFromHash(), XXH_readBE32(), and XXH_readLE32_align().

XXH_swap64()

static U64 XXH_swap64 ( U64  x )

static

Definition at line 268 of file xxhash.c.

{
    return  ((x << 56) & 0xff00000000000000ULL) |
            ((x << 40) & 0x00ff000000000000ULL) |
            ((x << 24) & 0x0000ff0000000000ULL) |
            ((x << 8)  & 0x000000ff00000000ULL) |
            ((x >> 8)  & 0x00000000ff000000ULL) |
            ((x >> 24) & 0x0000000000ff0000ULL) |
            ((x >> 40) & 0x000000000000ff00ULL) |
            ((x >> 56) & 0x00000000000000ffULL);
}

Referenced by XXH64_canonicalFromHash(), XXH_readBE64(), and XXH_readLE64_align().

XXH_versionNumber()

XXH_PUBLIC_API unsigned XXH_versionNumber

(

void

)

Definition at line 357 of file xxhash.c.

{ return XXH_VERSION_NUMBER; }

Variable Documentation

g_one

const int g_one = 1

static

Definition at line 289 of file xxhash.c.

PRIME32_1

const U32 PRIME32_1 = 2654435761U

static

Definition at line 345 of file xxhash.c.

Referenced by XXH32_digest_endian(), XXH32_endian_align(), XXH32_reset(), and XXH32_round().

PRIME32_2

const U32 PRIME32_2 = 2246822519U

static

Definition at line 346 of file xxhash.c.

Referenced by XXH32_digest_endian(), XXH32_endian_align(), XXH32_reset(), and XXH32_round().

PRIME32_3

const U32 PRIME32_3 = 3266489917U

static

Definition at line 347 of file xxhash.c.

Referenced by XXH32_digest_endian(), and XXH32_endian_align().

PRIME32_4

const U32 PRIME32_4 = 668265263U

static

Definition at line 348 of file xxhash.c.

Referenced by XXH32_digest_endian(), and XXH32_endian_align().

PRIME32_5

const U32 PRIME32_5 = 374761393U

static

Definition at line 349 of file xxhash.c.

Referenced by XXH32_digest_endian(), and XXH32_endian_align().

PRIME64_1

const U64 PRIME64_1 = 11400714785074694791ULL

static

Definition at line 351 of file xxhash.c.

Referenced by XXH64_digest_endian(), XXH64_endian_align(), XXH64_mergeRound(), XXH64_reset(), and XXH64_round().

PRIME64_2

const U64 PRIME64_2 = 14029467366897019727ULL

static

Definition at line 352 of file xxhash.c.

Referenced by XXH64_digest_endian(), XXH64_endian_align(), XXH64_reset(), and XXH64_round().

PRIME64_3

const U64 PRIME64_3 = 1609587929392839161ULL

static

Definition at line 353 of file xxhash.c.

Referenced by XXH64_digest_endian(), and XXH64_endian_align().

PRIME64_4

const U64 PRIME64_4 = 9650029242287828579ULL

static

Definition at line 354 of file xxhash.c.

Referenced by XXH64_digest_endian(), XXH64_endian_align(), and XXH64_mergeRound().

PRIME64_5

const U64 PRIME64_5 = 2870177450012600261ULL

static

Definition at line 355 of file xxhash.c.

Referenced by XXH64_digest_endian(), and XXH64_endian_align().