R0dn3yS/android_kernel_xiaomi_sm7250
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

lz4: staticify functions

Browse Source 
Signed-off-by: Park Ju Hyung <qkrwngud825@gmail.com>
This commit is contained in:
Park Ju Hyung 2019-09-30 21:52:05 +09:00 committed by spakkkk
parent 73837ba8d0
commit 73dec0bdf8
4 changed files with 29 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
include/linux/lz4.h
View File

@ -218,7 +218,7 @@ int LZ4_compress_default(const char *source, char *dest, int inputSize,
* Return: Number of bytes written into buffer 'dest' * Return: Number of bytes written into buffer 'dest'
* (necessarily <= maxOutputSize) or 0 if compression fails * (necessarily <= maxOutputSize) or 0 if compression fails
*/ */
int LZ4_compress_fast(const char *source, char *dest, int inputSize, static int LZ4_compress_fast(const char *source, char *dest, int inputSize,
int maxOutputSize, int acceleration, void *wrkmem); int maxOutputSize, int acceleration, void *wrkmem);
/** /**
@ -242,7 +242,7 @@ int LZ4_compress_fast(const char *source, char *dest, int inputSize,
* Return: Number of bytes written into 'dest' (necessarily <= targetDestSize) * Return: Number of bytes written into 'dest' (necessarily <= targetDestSize)
* or 0 if compression fails * or 0 if compression fails
*/ */
int LZ4_compress_destSize(const char *source, char *dest, int *sourceSizePtr, static int LZ4_compress_destSize(const char *source, char *dest, int *sourceSizePtr,
int targetDestSize, void *wrkmem); int targetDestSize, void *wrkmem);
/*-************************************************************************ /*-************************************************************************
@ -317,7 +317,7 @@ int LZ4_decompress_safe(const char *source, char *dest, int compressedSize,
* or a negative result in case of error * or a negative result in case of error
* *
*/ */
int LZ4_decompress_safe_partial(const char *source, char *dest, static int LZ4_decompress_safe_partial(const char *source, char *dest,
int compressedSize, int targetOutputSize, int maxDecompressedSize); int compressedSize, int targetOutputSize, int maxDecompressedSize);
/*-************************************************************************ /*-************************************************************************
@ -358,7 +358,7 @@ int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity,
* Use this function to init an allocated `LZ4_streamHC_t` structure * Use this function to init an allocated `LZ4_streamHC_t` structure
* and start a new compression. * and start a new compression.
*/ */
void LZ4_resetStreamHC(LZ4_streamHC_t *streamHCPtr, int compressionLevel); static void LZ4_resetStreamHC(LZ4_streamHC_t *streamHCPtr, int compressionLevel);
/** /**
* LZ4_loadDictHC() - Load a static dictionary into LZ4_streamHC * LZ4_loadDictHC() - Load a static dictionary into LZ4_streamHC
@ -373,7 +373,7 @@ void LZ4_resetStreamHC(LZ4_streamHC_t *streamHCPtr, int compressionLevel);
* *
* Return : dictionary size, in bytes (necessarily <= 64 KB) * Return : dictionary size, in bytes (necessarily <= 64 KB)
*/ */
int LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary, static int LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
int dictSize); int dictSize);
/** /**
@ -412,7 +412,7 @@ int LZ4_loadDictHC(LZ4_streamHC_t *streamHCPtr, const char *dictionary,
* *
* Return: Number of bytes written into buffer 'dst' or 0 if compression fails * Return: Number of bytes written into buffer 'dst' or 0 if compression fails
*/ */
int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src, static int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src,
char *dst, int srcSize, int maxDstSize); char *dst, int srcSize, int maxDstSize);
/** /**
@ -431,7 +431,7 @@ int LZ4_compress_HC_continue(LZ4_streamHC_t *streamHCPtr, const char *src,
* Return : saved dictionary size in bytes (necessarily <= maxDictSize), * Return : saved dictionary size in bytes (necessarily <= maxDictSize),
* or 0 if error. * or 0 if error.
*/ */
int LZ4_saveDictHC(LZ4_streamHC_t *streamHCPtr, char *safeBuffer, static int LZ4_saveDictHC(LZ4_streamHC_t *streamHCPtr, char *safeBuffer,
int maxDictSize); int maxDictSize);
/*-********************************************* /*-*********************************************
@ -447,7 +447,7 @@ int LZ4_saveDictHC(LZ4_streamHC_t *streamHCPtr, char *safeBuffer,
* Use this function to init an allocated `LZ4_stream_t` structure * Use this function to init an allocated `LZ4_stream_t` structure
* and start a new compression. * and start a new compression.
*/ */
void LZ4_resetStream(LZ4_stream_t *LZ4_stream); static __always_inline void LZ4_resetStream(LZ4_stream_t *LZ4_stream);
/** /**
* LZ4_loadDict() - Load a static dictionary into LZ4_stream * LZ4_loadDict() - Load a static dictionary into LZ4_stream
@ -504,7 +504,7 @@ int LZ4_saveDict(LZ4_stream_t *streamPtr, char *safeBuffer, int dictSize);
* *
* Return: Number of bytes written into buffer 'dst' or 0 if compression fails * Return: Number of bytes written into buffer 'dst' or 0 if compression fails
*/ */
int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src, static int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src,
char *dst, int srcSize, int maxDstSize, int acceleration); char *dst, int srcSize, int maxDstSize, int acceleration);
/** /**
@ -518,7 +518,7 @@ int LZ4_compress_fast_continue(LZ4_stream_t *streamPtr, const char *src,
* *
* Return: 1 if OK, 0 if error * Return: 1 if OK, 0 if error
*/ */
int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
const char *dictionary, int dictSize); const char *dictionary, int dictSize);
/** /**
@ -557,7 +557,7 @@ int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
* (necessarily <= maxDecompressedSize) * (necessarily <= maxDecompressedSize)
* or a negative result in case of error * or a negative result in case of error
*/ */
int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
const char *source, char *dest, int compressedSize, const char *source, char *dest, int compressedSize,
int maxDecompressedSize); int maxDecompressedSize);
@ -596,7 +596,7 @@ int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
* (necessarily <= maxDecompressedSize) * (necessarily <= maxDecompressedSize)
* or a negative result in case of error * or a negative result in case of error
*/ */
int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
const char *source, char *dest, int originalSize); const char *source, char *dest, int originalSize);
/** /**
@ -619,7 +619,7 @@ int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
* (necessarily <= maxDecompressedSize) * (necessarily <= maxDecompressedSize)
* or a negative result in case of error * or a negative result in case of error
*/ */
int LZ4_decompress_safe_usingDict(const char *source, char *dest, static int LZ4_decompress_safe_usingDict(const char *source, char *dest,
int compressedSize, int maxDecompressedSize, const char *dictStart, int compressedSize, int maxDecompressedSize, const char *dictStart,
int dictSize); int dictSize);
@ -642,7 +642,7 @@ int LZ4_decompress_safe_usingDict(const char *source, char *dest,
* (necessarily <= maxDecompressedSize) * (necessarily <= maxDecompressedSize)
* or a negative result in case of error * or a negative result in case of error
*/ */
int LZ4_decompress_fast_usingDict(const char *source, char *dest, static int LZ4_decompress_fast_usingDict(const char *source, char *dest,
int originalSize, const char *dictStart, int dictSize); int originalSize, const char *dictStart, int dictSize);
#endif #endif

11
lib/lz4/lz4_compress.c
View File

@ -500,13 +500,12 @@ static int LZ4_compress_fast_extState(
} }
} }
int LZ4_compress_fast(const char *source, char *dest, int inputSize, static int LZ4_compress_fast(const char *source, char *dest, int inputSize,
int maxOutputSize, int acceleration, void *wrkmem) int maxOutputSize, int acceleration, void *wrkmem)
{ {
return LZ4_compress_fast_extState(wrkmem, source, dest, inputSize, return LZ4_compress_fast_extState(wrkmem, source, dest, inputSize,
maxOutputSize, acceleration); maxOutputSize, acceleration);
} }
EXPORT_SYMBOL(LZ4_compress_fast);
int LZ4_compress_default(const char *source, char *dest, int inputSize, int LZ4_compress_default(const char *source, char *dest, int inputSize,
int maxOutputSize, void *wrkmem) int maxOutputSize, void *wrkmem)
@ -752,7 +751,7 @@ static int LZ4_compress_destSize_extState(
} }
int LZ4_compress_destSize( static int LZ4_compress_destSize(
const char *src, const char *src,
char *dst, char *dst,
int *srcSizePtr, int *srcSizePtr,
@ -762,12 +761,11 @@ int LZ4_compress_destSize(
return LZ4_compress_destSize_extState(wrkmem, src, dst, srcSizePtr, return LZ4_compress_destSize_extState(wrkmem, src, dst, srcSizePtr,
targetDstSize); targetDstSize);
} }
EXPORT_SYMBOL(LZ4_compress_destSize);
/*-****************************** /*-******************************
* Streaming functions * Streaming functions
********************************/ ********************************/
void LZ4_resetStream(LZ4_stream_t *LZ4_stream) static FORCE_INLINE void LZ4_resetStream(LZ4_stream_t *LZ4_stream)
{ {
memset(LZ4_stream, 0, sizeof(LZ4_stream_t)); memset(LZ4_stream, 0, sizeof(LZ4_stream_t));
} }
@ -854,7 +852,7 @@ int LZ4_saveDict(LZ4_stream_t *LZ4_dict, char *safeBuffer, int dictSize)
} }
EXPORT_SYMBOL(LZ4_saveDict); EXPORT_SYMBOL(LZ4_saveDict);
int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream, const char *source, static int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream, const char *source,
char *dest, int inputSize, int maxOutputSize, int acceleration) char *dest, int inputSize, int maxOutputSize, int acceleration)
{ {
LZ4_stream_t_internal *streamPtr = &LZ4_stream->internal_donotuse; LZ4_stream_t_internal *streamPtr = &LZ4_stream->internal_donotuse;
@ -934,7 +932,6 @@ int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream, const char *source,
return result; return result;
} }
} }
EXPORT_SYMBOL(LZ4_compress_fast_continue);
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 compressor"); MODULE_DESCRIPTION("LZ4 compressor");

23
lib/lz4/lz4_decompress.c
View File

@ -724,7 +724,7 @@ int LZ4_decompress_safe(const char *source, char *dest,
noDict, (BYTE *)dest, NULL, 0); noDict, (BYTE *)dest, NULL, 0);
} }
int LZ4_decompress_safe_partial(const char *src, char *dst, static int LZ4_decompress_safe_partial(const char *src, char *dst,
int compressedSize, int targetOutputSize, int dstCapacity) int compressedSize, int targetOutputSize, int dstCapacity)
{ {
dstCapacity = min(targetOutputSize, dstCapacity); dstCapacity = min(targetOutputSize, dstCapacity);
@ -765,7 +765,7 @@ static int LZ4_decompress_safe_withSmallPrefix(const char *source, char *dest,
(BYTE *)dest - prefixSize, NULL, 0); (BYTE *)dest - prefixSize, NULL, 0);
} }
int LZ4_decompress_safe_forceExtDict(const char *source, char *dest, static int LZ4_decompress_safe_forceExtDict(const char *source, char *dest,
int compressedSize, int maxOutputSize, int compressedSize, int maxOutputSize,
const void *dictStart, size_t dictSize) const void *dictStart, size_t dictSize)
{ {
@ -819,7 +819,7 @@ int LZ4_decompress_fast_doubleDict(const char *source, char *dest,
/* ===== streaming decompression functions ===== */ /* ===== streaming decompression functions ===== */
int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
const char *dictionary, int dictSize) const char *dictionary, int dictSize)
{ {
LZ4_streamDecode_t_internal *lz4sd = LZ4_streamDecode_t_internal *lz4sd =
@ -842,7 +842,7 @@ int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode,
* decoded data into a safe buffer, * decoded data into a safe buffer,
* and indicate where it stands using LZ4_setStreamDecode() * and indicate where it stands using LZ4_setStreamDecode()
*/ */
int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
const char *source, char *dest, int compressedSize, int maxOutputSize) const char *source, char *dest, int compressedSize, int maxOutputSize)
{ {
LZ4_streamDecode_t_internal *lz4sd = LZ4_streamDecode_t_internal *lz4sd =
@ -895,7 +895,7 @@ int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode,
return result; return result;
} }
int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode, static int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
const char *source, char *dest, int originalSize) const char *source, char *dest, int originalSize)
{ {
LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse; LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse;
@ -934,7 +934,7 @@ int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode,
return result; return result;
} }
int LZ4_decompress_safe_usingDict(const char *source, char *dest, static int LZ4_decompress_safe_usingDict(const char *source, char *dest,
int compressedSize, int maxOutputSize, int compressedSize, int maxOutputSize,
const char *dictStart, int dictSize) const char *dictStart, int dictSize)
{ {
@ -952,7 +952,7 @@ int LZ4_decompress_safe_usingDict(const char *source, char *dest,
compressedSize, maxOutputSize, dictStart, dictSize); compressedSize, maxOutputSize, dictStart, dictSize);
} }
int LZ4_decompress_fast_usingDict(const char *source, char *dest, static int LZ4_decompress_fast_usingDict(const char *source, char *dest,
int originalSize, int originalSize,
const char *dictStart, int dictSize) const char *dictStart, int dictSize)
{ {
@ -964,15 +964,6 @@ int LZ4_decompress_fast_usingDict(const char *source, char *dest,
} }
#ifndef STATIC #ifndef STATIC
EXPORT_SYMBOL(LZ4_decompress_safe);
EXPORT_SYMBOL(LZ4_decompress_safe_partial);
EXPORT_SYMBOL(LZ4_decompress_fast);
EXPORT_SYMBOL(LZ4_setStreamDecode);
EXPORT_SYMBOL(LZ4_decompress_safe_continue);
EXPORT_SYMBOL(LZ4_decompress_fast_continue);
EXPORT_SYMBOL(LZ4_decompress_safe_usingDict);
EXPORT_SYMBOL(LZ4_decompress_fast_usingDict);
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 decompressor"); MODULE_DESCRIPTION("LZ4 decompressor");
#endif #endif

11
lib/lz4/lz4hc_compress.c
View File

@ -616,13 +616,13 @@ EXPORT_SYMBOL(LZ4_compress_HC);
/************************************** /**************************************
* Streaming Functions * Streaming Functions
**************************************/ **************************************/
void LZ4_resetStreamHC(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel) static void LZ4_resetStreamHC(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel)
{ {
LZ4_streamHCPtr->internal_donotuse.base = NULL; LZ4_streamHCPtr->internal_donotuse.base = NULL;
LZ4_streamHCPtr->internal_donotuse.compressionLevel = (unsigned int)compressionLevel; LZ4_streamHCPtr->internal_donotuse.compressionLevel = (unsigned int)compressionLevel;
} }
int LZ4_loadDictHC(LZ4_streamHC_t *LZ4_streamHCPtr, static int LZ4_loadDictHC(LZ4_streamHC_t *LZ4_streamHCPtr,
const char *dictionary, const char *dictionary,
int dictSize) int dictSize)
{ {
@ -638,7 +638,6 @@ int LZ4_loadDictHC(LZ4_streamHC_t *LZ4_streamHCPtr,
ctxPtr->end = (const BYTE *)dictionary + dictSize; ctxPtr->end = (const BYTE *)dictionary + dictSize;
return dictSize; return dictSize;
} }
EXPORT_SYMBOL(LZ4_loadDictHC);
/* compression */ /* compression */
@ -713,7 +712,7 @@ static int LZ4_compressHC_continue_generic(
inputSize, maxOutputSize, ctxPtr->compressionLevel, limit); inputSize, maxOutputSize, ctxPtr->compressionLevel, limit);
} }
int LZ4_compress_HC_continue( static int LZ4_compress_HC_continue(
LZ4_streamHC_t *LZ4_streamHCPtr, LZ4_streamHC_t *LZ4_streamHCPtr,
const char *source, const char *source,
char *dest, char *dest,
@ -727,11 +726,10 @@ int LZ4_compress_HC_continue(
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, return LZ4_compressHC_continue_generic(LZ4_streamHCPtr,
source, dest, inputSize, maxOutputSize, noLimit); source, dest, inputSize, maxOutputSize, noLimit);
} }
EXPORT_SYMBOL(LZ4_compress_HC_continue);
/* dictionary saving */ /* dictionary saving */
int LZ4_saveDictHC( static int LZ4_saveDictHC(
LZ4_streamHC_t *LZ4_streamHCPtr, LZ4_streamHC_t *LZ4_streamHCPtr,
char *safeBuffer, char *safeBuffer,
int dictSize) int dictSize)
@ -762,7 +760,6 @@ int LZ4_saveDictHC(
} }
return dictSize; return dictSize;
} }
EXPORT_SYMBOL(LZ4_saveDictHC);
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("LZ4 HC compressor"); MODULE_DESCRIPTION("LZ4 HC compressor");