zstd/zstd_v05.c at 1.x · dqminh/zstd

Repository navigation

8000

* This source code is licensed under both the BSD-style license (found in the

* LICENSE file in the root directory of this source tree) and the GPLv2 (found

* in the COPYING file in the root directory of this source tree).

* You may select, at your option, one of the above-listed licenses.

/*- Dependencies -*/

#include "zstd_v05.h"

#include "error_private.h"

/* ******************************************************************

mem.h

low-level memory access routines

BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are

met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

in the documentation and/or other materials provided with the

distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

You can contact the author at :

- FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy

- Public forum : https://groups.google.com/forum/#!forum/lz4c

****************************************************************** */

#ifndef MEM_H_MODULE

#define MEM_H_MODULE

#if defined (__cplusplus)

extern "C" {

#endif

/*-****************************************

* Dependencies

******************************************/

#include <stddef.h> /* size_t, ptrdiff_t */

#include <string.h> /* memcpy */

/*-****************************************

* Compiler specifics

******************************************/

#if defined(__GNUC__)

# define MEM_STATIC static __attribute__((unused))

#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

# define MEM_STATIC static inline

#elif defined(_MSC_VER)

# define MEM_STATIC static __inline

#else

# define MEM_STATIC static /* this version may generate warnings for unused static functions; disable the relevant warning */

#endif

/*-**************************************************************

* Basic Types

*****************************************************************/

#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)

# include <stdint.h>

typedef uint8_t BYTE;

typedef uint16_t U16;

typedef int16_t S16;

typedef uint32_t U32;

typedef int32_t S32;

typedef uint64_t U64;

typedef int64_t S64;

#else

typedef unsigned char BYTE;

typedef unsigned short U16;

typedef signed short S16;

typedef unsigned int U32;

typedef signed int S32;

typedef unsigned long long U64;

typedef signed long long S64;

#endif

/*-**************************************************************

* Memory I/O

*****************************************************************/

/* MEM_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 is portable but violate C standard.

* It can generate buggy code on targets depending on alignment.

* In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)

* See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.

* Prefer these methods in priority order (0 > 1 > 2)

#ifndef MEM_FORCE_MEMORY_ACCESS /* can be defined externally, on command line for example */

# if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )

# define MEM_FORCE_MEMORY_ACCESS 2

# elif (defined(__INTEL_COMPILER) && !defined(WIN32)) || \

(defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))

# define MEM_FORCE_MEMORY_ACCESS 1

# endif

#endif

MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }

MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }

MEM_STATIC unsigned MEM_isLittleEndian(void)

{

const union { U32 u; BYTE c[4]; } 1 }; /* don't use static : performance detrimental */

return one.c[0];

}

#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)

/* violates C standard, by lying on structure alignment.

Only use if no other choice to achieve best performance on target platform */

MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }

MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }

MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }

MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }

MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }

MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }

#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)

/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */

/* currently only defined for gcc and icc */

typedef union { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;

MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }

MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }

MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }

MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }

MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }

MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }

#else

/* default method, safe and standard.

can sometimes prove slower */

MEM_STATIC U16 MEM_read16(const void* memPtr)

{

U16 val; memcpy(&val, memPtr, sizeof(val)); return val;

}

MEM_STATIC U32 MEM_read32(const void* memPtr)

{

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

}

MEM_STATIC U64 MEM_read64(const void* memPtr)

{

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

}

MEM_STATIC void MEM_write16(void* memPtr, U16 value)

{

memcpy(memPtr, &value, sizeof(value));

}

MEM_STATIC void MEM_write32(void* memPtr, U32 value)

{

memcpy(memPtr, &value, sizeof(value));

}

MEM_STATIC void MEM_write64(void* memPtr, U64 value)

{

memcpy(memPtr, &value, sizeof(value));

}

#endif /* MEM_FORCE_MEMORY_ACCESS */

MEM_STATIC U16 MEM_readLE16(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read16(memPtr);

else {

const BYTE* p = (const BYTE*)memPtr;

return (U16)(p[0] + (p[1]<<8));

}

MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)

{

if (MEM_isLittleEndian()) {

MEM_write16(memPtr, val);

} else {

BYTE* p = (BYTE*)memPtr;

p[0] = (BYTE)val;

p[1] = (BYTE)(val>>8);

}

MEM_STATIC U32 MEM_readLE32(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read32(memPtr);

else {

const BYTE* p = (const BYTE*)memPtr;

return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));

}

MEM_STATIC U64 MEM_readLE64(const void* memPtr)

{

if (MEM_isLittleEndian())

return MEM_read64(memPtr);

else {

const BYTE* p = (const BYTE*)memPtr;

return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)

+ ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));

}

MEM_STATIC size_t MEM_readLEST(const void* memPtr)

{

if (MEM_32bits())

return (size_t)MEM_readLE32(memPtr);

else

return (size_t)MEM_readLE64(memPtr);

}

#if defined (__cplusplus)

}

#endif

#endif /* MEM_H_MODULE */

zstd - standard compression library

Header File for static linking only