[mirror_ubuntu-hirsute-kernel.git] / lib / lz4 / lz4defs.h

#ifndef __LZ4DEFS_H__
#define __LZ4DEFS_H__

/*
 * lz4defs.h -- common and architecture specific defines for the kernel usage

 * LZ4 - Fast LZ compression algorithm
 * Copyright (C) 2011-2016, Yann Collet.
 * 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
 * copyright notice, this list of conditions and the following disclaimer
 * 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 :
 *	- LZ4 homepage : http://www.lz4.org
 *	- LZ4 source repository : https://github.com/lz4/lz4
 *
 *	Changed for kernel usage by:
 *	Sven Schmidt <4sschmid@informatik.uni-hamburg.de>
 */

#include <asm/unaligned.h>
#include <linux/string.h>	 /* memset, memcpy */

#define FORCE_INLINE __always_inline

/*-************************************
 *	Basic Types
 **************************************/
#include <linux/types.h>

typedef	uint8_t BYTE;
typedef uint16_t U16;
typedef uint32_t U32;
typedef	int32_t S32;
typedef uint64_t U64;
typedef uintptr_t uptrval;

/*-************************************
 *	Architecture specifics
 **************************************/
#if defined(CONFIG_64BIT)
#define LZ4_ARCH64 1
#else
#define LZ4_ARCH64 0
#endif

#if defined(__LITTLE_ENDIAN)
#define LZ4_LITTLE_ENDIAN 1
#else
#define LZ4_LITTLE_ENDIAN 0
#endif

/*-************************************
 *	Constants
 **************************************/
#define MINMATCH 4

#define WILDCOPYLENGTH 8
#define LASTLITERALS 5
#define MFLIMIT (WILDCOPYLENGTH + MINMATCH)
/*
 * ensure it's possible to write 2 x wildcopyLength
 * without overflowing output buffer
 */
#define MATCH_SAFEGUARD_DISTANCE  ((2 * WILDCOPYLENGTH) - MINMATCH)

/* Increase this value ==> compression run slower on incompressible data */
#define LZ4_SKIPTRIGGER 6

#define HASH_UNIT sizeof(size_t)

#define KB (1 << 10)
#define MB (1 << 20)
#define GB (1U << 30)

#define MAXD_LOG 16
#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
#define STEPSIZE sizeof(size_t)

#define ML_BITS	4
#define ML_MASK	((1U << ML_BITS) - 1)
#define RUN_BITS (8 - ML_BITS)
#define RUN_MASK ((1U << RUN_BITS) - 1)

/*-************************************
 *	Reading and writing into memory
 **************************************/
static FORCE_INLINE U16 LZ4_read16(const void *ptr)
{
	return get_unaligned((const U16 *)ptr);
}

static FORCE_INLINE U32 LZ4_read32(const void *ptr)
{
	return get_unaligned((const U32 *)ptr);
}

static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr)
{
	return get_unaligned((const size_t *)ptr);
}

static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value)
{
	put_unaligned(value, (U16 *)memPtr);
}

static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value)
{
	put_unaligned(value, (U32 *)memPtr);
}

static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr)
{
	return get_unaligned_le16(memPtr);
}

static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value)
{
	return put_unaligned_le16(value, memPtr);
}

static FORCE_INLINE void LZ4_copy8(void *dst, const void *src)
{
#if LZ4_ARCH64
	U64 a = get_unaligned((const U64 *)src);

	put_unaligned(a, (U64 *)dst);
#else
	U32 a = get_unaligned((const U32 *)src);
	U32 b = get_unaligned((const U32 *)src + 1);

	put_unaligned(a, (U32 *)dst);
	put_unaligned(b, (U32 *)dst + 1);
#endif
}

/*
 * customized variant of memcpy,
 * which can overwrite up to 7 bytes beyond dstEnd
 */
static FORCE_INLINE void LZ4_wildCopy(void *dstPtr,
	const void *srcPtr, void *dstEnd)
{
	BYTE *d = (BYTE *)dstPtr;
	const BYTE *s = (const BYTE *)srcPtr;
	BYTE *const e = (BYTE *)dstEnd;

	do {
		LZ4_copy8(d, s);
		d += 8;
		s += 8;
	} while (d < e);
}

static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val)
{
#if LZ4_LITTLE_ENDIAN
	return __ffs(val) >> 3;
#else
	return (BITS_PER_LONG - 1 - __fls(val)) >> 3;
#endif
}

static FORCE_INLINE unsigned int LZ4_count(
	const BYTE *pIn,
	const BYTE *pMatch,
	const BYTE *pInLimit)
{
	const BYTE *const pStart = pIn;

	while (likely(pIn < pInLimit - (STEPSIZE - 1))) {
		size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);

		if (!diff) {
			pIn += STEPSIZE;
			pMatch += STEPSIZE;
			continue;
		}

		pIn += LZ4_NbCommonBytes(diff);

		return (unsigned int)(pIn - pStart);
	}

#if LZ4_ARCH64
	if ((pIn < (pInLimit - 3))
		&& (LZ4_read32(pMatch) == LZ4_read32(pIn))) {
		pIn += 4;
		pMatch += 4;
	}
#endif

	if ((pIn < (pInLimit - 1))
		&& (LZ4_read16(pMatch) == LZ4_read16(pIn))) {
		pIn += 2;
		pMatch += 2;
	}

	if ((pIn < pInLimit) && (*pMatch == *pIn))
		pIn++;

	return (unsigned int)(pIn - pStart);
}

typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive;
typedef enum { byPtr, byU32, byU16 } tableType_t;

typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;
typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;

typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;

#define LZ4_STATIC_ASSERT(c)	BUILD_BUG_ON(!(c))

#endif
Commit	Line	Data
4e1a33b1 SS	1	#ifndef __LZ4DEFS_H__
	2	#define __LZ4DEFS_H__
	3
cffb78b0	4	/*
4e1a33b1 SS	5	* lz4defs.h -- common and architecture specific defines for the kernel usage
	6
	7	* LZ4 - Fast LZ compression algorithm
	8	* Copyright (C) 2011-2016, Yann Collet.
	9	* BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions are
	12	* met:
	13	* * Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* * Redistributions in binary form must reproduce the above
	16	* copyright notice, this list of conditions and the following disclaimer
	17	* in the documentation and/or other materials provided with the
	18	* distribution.
	19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	20	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	21	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	22	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	23	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	24	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	25	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	26	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	27	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	28	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	29	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	30	* You can contact the author at :
	31	* - LZ4 homepage : http://www.lz4.org
	32	* - LZ4 source repository : https://github.com/lz4/lz4
cffb78b0	33	*
4e1a33b1 SS	34	* Changed for kernel usage by:
4e1a33b1 SS	35	* Sven Schmidt <4sschmid@informatik.uni-hamburg.de>
cffb78b0 KL	36	*/
cffb78b0 KL	37
4e1a33b1 SS	38	#include <asm/unaligned.h>
	39	#include <linux/string.h> /* memset, memcpy */
	40
	41	#define FORCE_INLINE __always_inline
	42
	43	/-***********************************
	44	* Basic Types
	45	**************************************/
	46	#include <linux/types.h>
	47
	48	typedef uint8_t BYTE;
	49	typedef uint16_t U16;
	50	typedef uint32_t U32;
	51	typedef int32_t S32;
	52	typedef uint64_t U64;
	53	typedef uintptr_t uptrval;
	54
	55	/-***********************************
	56	* Architecture specifics
	57	**************************************/
3e26a691	58	#if defined(CONFIG_64BIT)
cffb78b0 KL	59	#define LZ4_ARCH64 1
	60	#else
	61	#define LZ4_ARCH64 0
	62	#endif
	63
4e1a33b1 SS	64	#if defined(__LITTLE_ENDIAN)
	65	#define LZ4_LITTLE_ENDIAN 1
	66	#else
	67	#define LZ4_LITTLE_ENDIAN 0
cffb78b0 KL	68	#endif
cffb78b0 KL	69
4e1a33b1 SS	70	/-***********************************
	71	* Constants
	72	**************************************/
	73	#define MINMATCH 4
	74
	75	#define WILDCOPYLENGTH 8
	76	#define LASTLITERALS 5
	77	#define MFLIMIT (WILDCOPYLENGTH + MINMATCH)
2209fda3 GX	78	/*
	79	* ensure it's possible to write 2 x wildcopyLength
	80	* without overflowing output buffer
	81	*/
	82	#define MATCH_SAFEGUARD_DISTANCE ((2 * WILDCOPYLENGTH) - MINMATCH)
4e1a33b1 SS	83
	84	/* Increase this value ==> compression run slower on incompressible data */
	85	#define LZ4_SKIPTRIGGER 6
	86
	87	#define HASH_UNIT sizeof(size_t)
	88
	89	#define KB (1 << 10)
	90	#define MB (1 << 20)
	91	#define GB (1U << 30)
	92
	93	#define MAXD_LOG 16
	94	#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)
	95	#define STEPSIZE sizeof(size_t)
	96
	97	#define ML_BITS 4
	98	#define ML_MASK ((1U << ML_BITS) - 1)
cffb78b0 KL	99	#define RUN_BITS (8 - ML_BITS)
cffb78b0 KL	100	#define RUN_MASK ((1U << RUN_BITS) - 1)
4e1a33b1 SS	101
	102	/-***********************************
	103	* Reading and writing into memory
	104	**************************************/
	105	static FORCE_INLINE U16 LZ4_read16(const void *ptr)
	106	{
	107	return get_unaligned((const U16 *)ptr);
	108	}
	109
	110	static FORCE_INLINE U32 LZ4_read32(const void *ptr)
	111	{
	112	return get_unaligned((const U32 *)ptr);
	113	}
	114
	115	static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr)
	116	{
	117	return get_unaligned((const size_t *)ptr);
	118	}
	119
	120	static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value)
	121	{
	122	put_unaligned(value, (U16 *)memPtr);
	123	}
	124
	125	static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value)
	126	{
	127	put_unaligned(value, (U32 *)memPtr);
	128	}
	129
	130	static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr)
	131	{
	132	return get_unaligned_le16(memPtr);
	133	}
	134
	135	static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value)
	136	{
	137	return put_unaligned_le16(value, memPtr);
	138	}
	139
	140	static FORCE_INLINE void LZ4_copy8(void dst, const void src)
	141	{
	142	#if LZ4_ARCH64
	143	U64 a = get_unaligned((const U64 *)src);
	144
	145	put_unaligned(a, (U64 *)dst);
	146	#else
	147	U32 a = get_unaligned((const U32 *)src);
	148	U32 b = get_unaligned((const U32 *)src + 1);
	149
	150	put_unaligned(a, (U32 *)dst);
	151	put_unaligned(b, (U32 *)dst + 1);
	152	#endif
	153	}
	154
	155	/*
	156	* customized variant of memcpy,
	157	* which can overwrite up to 7 bytes beyond dstEnd
	158	*/
	159	static FORCE_INLINE void LZ4_wildCopy(void *dstPtr,
	160	const void srcPtr, void dstEnd)
	161	{
	162	BYTE d = (BYTE )dstPtr;
	163	const BYTE s = (const BYTE )srcPtr;
	164	BYTE const e = (BYTE )dstEnd;
165
166	do {
167	LZ4_copy8(d, s);
168	d += 8;
169	s += 8;
170	} while (d < e);
171	}
172
173	static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val)
174	{
175	#if LZ4_LITTLE_ENDIAN
176	return __ffs(val) >> 3;
c72ac7a1	177	#else
4e1a33b1 SS	178	return (BITS_PER_LONG - 1 - __fls(val)) >> 3;
	179	#endif
	180	}
	181
	182	static FORCE_INLINE unsigned int LZ4_count(
	183	const BYTE *pIn,
	184	const BYTE *pMatch,
	185	const BYTE *pInLimit)
	186	{
	187	const BYTE *const pStart = pIn;
	188
	189	while (likely(pIn < pInLimit - (STEPSIZE - 1))) {
	190	size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
	191
	192	if (!diff) {
	193	pIn += STEPSIZE;
	194	pMatch += STEPSIZE;
	195	continue;
	196	}
	197
	198	pIn += LZ4_NbCommonBytes(diff);
	199
	200	return (unsigned int)(pIn - pStart);
	201	}
	202
	203	#if LZ4_ARCH64
	204	if ((pIn < (pInLimit - 3))
	205	&& (LZ4_read32(pMatch) == LZ4_read32(pIn))) {
	206	pIn += 4;
	207	pMatch += 4;
	208	}
c72ac7a1	209	#endif
cffb78b0	210
4e1a33b1 SS	211	if ((pIn < (pInLimit - 1))
	212	&& (LZ4_read16(pMatch) == LZ4_read16(pIn))) {
	213	pIn += 2;
	214	pMatch += 2;
	215	}
cffb78b0	216
4e1a33b1 SS	217	if ((pIn < pInLimit) && (pMatch == pIn))
4e1a33b1 SS	218	pIn++;
cffb78b0	219
4e1a33b1 SS	220	return (unsigned int)(pIn - pStart);
4e1a33b1 SS	221	}
cffb78b0	222
4e1a33b1 SS	223	typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive;
4e1a33b1 SS	224	typedef enum { byPtr, byU32, byU16 } tableType_t;
c72ac7a1	225
4e1a33b1 SS	226	typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;
4e1a33b1 SS	227	typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
c72ac7a1	228
4e1a33b1	229	typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;
2209fda3 GX	230	typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
	231
	232	#define LZ4_STATIC_ASSERT(c) BUILD_BUG_ON(!(c))
cffb78b0	233
4e1a33b1	234	#endif