facebook/zstd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[linux-kernel] Avoid including <string.h> in the tests

Browse Source
This commit is contained in:
Nick Terrell 2020-09-24 15:22:34 -07:00
parent 9ae0483858
commit 683150e59f
3 changed files with 22 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
contrib/linux-kernel/test/include/asm/unaligned.h
View File

@ -2,7 +2,6 @@
#define ASM_UNALIGNED_H #define ASM_UNALIGNED_H
#include <assert.h> #include <assert.h>
#include <linux/string.h>
#include <linux/types.h> #include <linux/types.h>
#define _LITTLE_ENDIAN 1 #define _LITTLE_ENDIAN 1
@ -33,7 +32,7 @@ static uint64_t _swap64(uint64_t in)
static uint16_t get_unaligned_le16(const void* memPtr) static uint16_t get_unaligned_le16(const void* memPtr)
{ {
uint16_t val; uint16_t val;
memcpy(&val, memPtr, sizeof(val)); __builtin_memcpy(&val, memPtr, sizeof(val));
if (!_isLittleEndian()) _swap16(val); if (!_isLittleEndian()) _swap16(val);
return val; return val;
} }
@ -41,7 +40,7 @@ static uint16_t get_unaligned_le16(const void* memPtr)
static uint32_t get_unaligned_le32(const void* memPtr) static uint32_t get_unaligned_le32(const void* memPtr)
{ {
uint32_t val; uint32_t val;
memcpy(&val, memPtr, sizeof(val)); __builtin_memcpy(&val, memPtr, sizeof(val));
if (!_isLittleEndian()) _swap32(val); if (!_isLittleEndian()) _swap32(val);
return val; return val;
} }
@ -49,7 +48,7 @@ static uint32_t get_unaligned_le32(const void* memPtr)
static uint64_t get_unaligned_le64(const void* memPtr) static uint64_t get_unaligned_le64(const void* memPtr)
{ {
uint64_t val; uint64_t val;
memcpy(&val, memPtr, sizeof(val)); __builtin_memcpy(&val, memPtr, sizeof(val));
if (!_isLittleEndian()) _swap64(val); if (!_isLittleEndian()) _swap64(val);
return val; return val;
} }
@ -57,26 +56,26 @@ static uint64_t get_unaligned_le64(const void* memPtr)
static void put_unaligned_le16(uint16_t value, void* memPtr) static void put_unaligned_le16(uint16_t value, void* memPtr)
{ {
if (!_isLittleEndian()) value = _swap16(value); if (!_isLittleEndian()) value = _swap16(value);
memcpy(memPtr, &value, sizeof(value)); __builtin_memcpy(memPtr, &value, sizeof(value));
} }
static void put_unaligned_le32(uint32_t value, void* memPtr) static void put_unaligned_le32(uint32_t value, void* memPtr)
{ {
if (!_isLittleEndian()) value = _swap32(value); if (!_isLittleEndian()) value = _swap32(value);
memcpy(memPtr, &value, sizeof(value)); __builtin_memcpy(memPtr, &value, sizeof(value));
} }
static void put_unaligned_le64(uint64_t value, void* memPtr) static void put_unaligned_le64(uint64_t value, void* memPtr)
{ {
if (!_isLittleEndian()) value = _swap64(value); if (!_isLittleEndian()) value = _swap64(value);
memcpy(memPtr, &value, sizeof(value)); __builtin_memcpy(memPtr, &value, sizeof(value));
} }
/* big endian */ /* big endian */
static uint32_t get_unaligned_be32(const void* memPtr) static uint32_t get_unaligned_be32(const void* memPtr)
{ {
uint32_t val; uint32_t val;
memcpy(&val, memPtr, sizeof(val)); __builtin_memcpy(&val, memPtr, sizeof(val));
if (_isLittleEndian()) _swap32(val); if (_isLittleEndian()) _swap32(val);
return val; return val;
} }
@ -84,7 +83,7 @@ static uint32_t get_unaligned_be32(const void* memPtr)
static uint64_t get_unaligned_be64(const void* memPtr) static uint64_t get_unaligned_be64(const void* memPtr)
{ {
uint64_t val; uint64_t val;
memcpy(&val, memPtr, sizeof(val)); __builtin_memcpy(&val, memPtr, sizeof(val));
if (_isLittleEndian()) _swap64(val); if (_isLittleEndian()) _swap64(val);
return val; return val;
} }
@ -92,13 +91,13 @@ static uint64_t get_unaligned_be64(const void* memPtr)
static void put_unaligned_be32(uint32_t value, void* memPtr) static void put_unaligned_be32(uint32_t value, void* memPtr)
{ {
if (_isLittleEndian()) value = _swap32(value); if (_isLittleEndian()) value = _swap32(value);
memcpy(memPtr, &value, sizeof(value)); __builtin_memcpy(memPtr, &value, sizeof(value));
} }
static void put_unaligned_be64(uint64_t value, void* memPtr) static void put_unaligned_be64(uint64_t value, void* memPtr)
{ {
if (_isLittleEndian()) value = _swap64(value); if (_isLittleEndian()) value = _swap64(value);
memcpy(memPtr, &value, sizeof(value)); __builtin_memcpy(memPtr, &value, sizeof(value));
} }
/* generic */ /* generic */

15
contrib/linux-kernel/test/include/linux/string.h
View File

@ -1,15 +0,0 @@
/*
* Copyright (c) 2016-2020, Facebook, Inc.
* All rights reserved.
*
* 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.
*/
#ifndef LINUX_STRING_H
#define LINUX_STRING_H
#include <string.h>
#endif

25
contrib/linux-kernel/test/include/linux/xxhash.h
View File

@ -301,7 +301,6 @@ XXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/string.h>
#include <linux/xxhash.h> #include <linux/xxhash.h>
/*-************************************* /*-*************************************
@ -336,12 +335,12 @@ static const uint64_t PRIME64_5 = 2870177450012600261ULL;
***************************/ ***************************/
XXH_API void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src) XXH_API void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src)
{ {
memcpy(dst, src, sizeof(*dst)); __builtin_memcpy(dst, src, sizeof(*dst));
} }
XXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src) XXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src)
{ {
memcpy(dst, src, sizeof(*dst)); __builtin_memcpy(dst, src, sizeof(*dst));
} }
/*-*************************** /*-***************************
@ -498,12 +497,12 @@ XXH_API void xxh32_reset(struct xxh32_state *statePtr, const uint32_t seed)
/* use a local state for memcpy() to avoid strict-aliasing warnings */ /* use a local state for memcpy() to avoid strict-aliasing warnings */
struct xxh32_state state; struct xxh32_state state;
memset(&state, 0, sizeof(state)); __builtin_memset(&state, 0, sizeof(state));
state.v1 = seed + PRIME32_1 + PRIME32_2; state.v1 = seed + PRIME32_1 + PRIME32_2;
state.v2 = seed + PRIME32_2; state.v2 = seed + PRIME32_2;
state.v3 = seed + 0; state.v3 = seed + 0;
state.v4 = seed - PRIME32_1; state.v4 = seed - PRIME32_1;
memcpy(statePtr, &state, sizeof(state)); __builtin_memcpy(statePtr, &state, sizeof(state));
} }
XXH_API void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed) XXH_API void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed)
@ -511,12 +510,12 @@ XXH_API void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed)
/* use a local state for memcpy() to avoid strict-aliasing warnings */ /* use a local state for memcpy() to avoid strict-aliasing warnings */
struct xxh64_state state; struct xxh64_state state;
memset(&state, 0, sizeof(state)); __builtin_memset(&state, 0, sizeof(state));
state.v1 = seed + PRIME64_1 + PRIME64_2; state.v1 = seed + PRIME64_1 + PRIME64_2;
state.v2 = seed + PRIME64_2; state.v2 = seed + PRIME64_2;
state.v3 = seed + 0; state.v3 = seed + 0;
state.v4 = seed - PRIME64_1; state.v4 = seed - PRIME64_1;
memcpy(statePtr, &state, sizeof(state)); __builtin_memcpy(statePtr, &state, sizeof(state));
} }
XXH_API int xxh32_update(struct xxh32_state *state, const void *input, const size_t len) XXH_API int xxh32_update(struct xxh32_state *state, const void *input, const size_t len)
@ -531,7 +530,7 @@ XXH_API int xxh32_update(struct xxh32_state *state, const void *input, const siz
state->large_len |= (len >= 16) | (state->total_len_32 >= 16); state->large_len |= (len >= 16) | (state->total_len_32 >= 16);
if (state->memsize + len < 16) { /* fill in tmp buffer */ if (state->memsize + len < 16) { /* fill in tmp buffer */
memcpy((uint8_t *)(state->mem32) + state->memsize, input, len); __builtin_memcpy((uint8_t *)(state->mem32) + state->memsize, input, len);
state->memsize += (uint32_t)len; state->memsize += (uint32_t)len;
return 0; return 0;
} }
@ -539,7 +538,7 @@ XXH_API int xxh32_update(struct xxh32_state *state, const void *input, const siz
if (state->memsize) { /* some data left from previous update */ if (state->memsize) { /* some data left from previous update */
const uint32_t *p32 = state->mem32; const uint32_t *p32 = state->mem32;
memcpy((uint8_t *)(state->mem32) + state->memsize, input, __builtin_memcpy((uint8_t *)(state->mem32) + state->memsize, input,
16 - state->memsize); 16 - state->memsize);
state->v1 = xxh32_round(state->v1, get_unaligned_le32(p32)); state->v1 = xxh32_round(state->v1, get_unaligned_le32(p32));
@ -580,7 +579,7 @@ XXH_API int xxh32_update(struct xxh32_state *state, const void *input, const siz
} }
if (p < b_end) { if (p < b_end) {
memcpy(state->mem32, p, (size_t)(b_end-p)); __builtin_memcpy(state->mem32, p, (size_t)(b_end-p));
state->memsize = (uint32_t)(b_end-p); state->memsize = (uint32_t)(b_end-p);
} }
@ -635,7 +634,7 @@ XXH_API int xxh64_update(struct xxh64_state *state, const void *input, const siz
state->total_len += len; state->total_len += len;
if (state->memsize + len < 32) { /* fill in tmp buffer */ if (state->memsize + len < 32) { /* fill in tmp buffer */
memcpy(((uint8_t *)state->mem64) + state->memsize, input, len); __builtin_memcpy(((uint8_t *)state->mem64) + state->memsize, input, len);
state->memsize += (uint32_t)len; state->memsize += (uint32_t)len;
return 0; return 0;
} }
@ -643,7 +642,7 @@ XXH_API int xxh64_update(struct xxh64_state *state, const void *input, const siz
if (state->memsize) { /* tmp buffer is full */ if (state->memsize) { /* tmp buffer is full */
uint64_t *p64 = state->mem64; uint64_t *p64 = state->mem64;
memcpy(((uint8_t *)p64) + state->memsize, input, __builtin_memcpy(((uint8_t *)p64) + state->memsize, input,
32 - state->memsize); 32 - state->memsize);
state->v1 = xxh64_round(state->v1, get_unaligned_le64(p64)); state->v1 = xxh64_round(state->v1, get_unaligned_le64(p64));
@ -683,7 +682,7 @@ XXH_API int xxh64_update(struct xxh64_state *state, const void *input, const siz
} }
if (p < b_end) { if (p < b_end) {
memcpy(state->mem64, p, (size_t)(b_end-p)); __builtin_memcpy(state->mem64, p, (size_t)(b_end-p));
state->memsize = (uint32_t)(b_end - p); state->memsize = (uint32_t)(b_end - p);
} }