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

diff --git a/contrib/linux-kernel/test/include/asm/unaligned.h b/contrib/linux-kernel/test/include/asm/unaligned.h
index 4f4828126344bf1c16f58bc01afd14327a85d5d3..6576b37ee939e7c5a9ef056d6b4b624115af6d37 100644 (file)
--- a/contrib/linux-kernel/test/include/asm/unaligned.h
+++ b/contrib/linux-kernel/test/include/asm/unaligned.h
@@ -2,7 +2,6 @@
 #define ASM_UNALIGNED_H
 
 #include <assert.h>
-#include <linux/string.h>
 #include <linux/types.h>
 
 #define _LITTLE_ENDIAN 1
@@ -33,7 +32,7 @@ static uint64_t _swap64(uint64_t in)
 static uint16_t get_unaligned_le16(const void* memPtr)
 {
     uint16_t val;
-    memcpy(&val, memPtr, sizeof(val));
+    __builtin_memcpy(&val, memPtr, sizeof(val));
     if (!_isLittleEndian()) _swap16(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)
 {
     uint32_t val;
-    memcpy(&val, memPtr, sizeof(val));
+    __builtin_memcpy(&val, memPtr, sizeof(val));
     if (!_isLittleEndian()) _swap32(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)
 {
     uint64_t val;
-    memcpy(&val, memPtr, sizeof(val));
+    __builtin_memcpy(&val, memPtr, sizeof(val));
     if (!_isLittleEndian()) _swap64(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)
 {
     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)
 {
     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)
 {
     if (!_isLittleEndian()) value = _swap64(value);
-    memcpy(memPtr, &value, sizeof(value));
+    __builtin_memcpy(memPtr, &value, sizeof(value));
 }
 
 /* big endian */
 static uint32_t get_unaligned_be32(const void* memPtr)
 {
     uint32_t val;
-    memcpy(&val, memPtr, sizeof(val));
+    __builtin_memcpy(&val, memPtr, sizeof(val));
     if (_isLittleEndian()) _swap32(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)
 {
     uint64_t val;
-    memcpy(&val, memPtr, sizeof(val));
+    __builtin_memcpy(&val, memPtr, sizeof(val));
     if (_isLittleEndian()) _swap64(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)
 {
     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)
 {
     if (_isLittleEndian()) value = _swap64(value);
-    memcpy(memPtr, &value, sizeof(value));
+    __builtin_memcpy(memPtr, &value, sizeof(value));
 }
 
 /* generic */

diff --git a/contrib/linux-kernel/test/include/linux/string.h b/contrib/linux-kernel/test/include/linux/string.h
deleted file mode 100644 (file)
index aeb5d9a..0000000
--- a/contrib/linux-kernel/test/include/linux/string.h
+++ /dev/null
@@ -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

diff --git a/contrib/linux-kernel/test/include/linux/xxhash.h b/contrib/linux-kernel/test/include/linux/xxhash.h
index 868c93d5de68708674c3964d378f03420fe88fe2..0a43bb275f3b333360fdc6c568fcfb825af1a255 100644 (file)
--- a/contrib/linux-kernel/test/include/linux/xxhash.h
+++ b/contrib/linux-kernel/test/include/linux/xxhash.h
@@ -301,7 +301,6 @@ XXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/string.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)
 {
-       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)
 {
-       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 */
        struct xxh32_state state;
 
-       memset(&state, 0, sizeof(state));
+       __builtin_memset(&state, 0, sizeof(state));
        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));
+       __builtin_memcpy(statePtr, &state, sizeof(state));
 }
 
 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 */
        struct xxh64_state state;
 
-       memset(&state, 0, sizeof(state));
+       __builtin_memset(&state, 0, sizeof(state));
        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));
+       __builtin_memcpy(statePtr, &state, sizeof(state));
 }
 
 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);
 
        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;
                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 */
                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);
 
                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) {
-               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);
        }
 
@@ -635,7 +634,7 @@ XXH_API int xxh64_update(struct xxh64_state *state, const void *input, const siz
        state->total_len += len;
 
        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;
                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 */
                uint64_t *p64 = state->mem64;
 
-               memcpy(((uint8_t *)p64) + state->memsize, input,
+               __builtin_memcpy(((uint8_t *)p64) + state->memsize, input,
                        32 - state->memsize);
 
                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) {
-               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);
        }