This is an archive of the discontinued LLVM Phabricator instance.

Differential D155515

[libc][NFC] Split memmove implementations per platform
ClosedPublic

Authored by gchatelet on Jul 17 2023, 2:23 PM.

Details

Reviewers
courbet
Commits
rG23dcdbfba790: [libc][NFC] Split memmove implementations per platform
Summary

This is a follow up on D154800 and D154770 to make the code structure more principled and avoid too many nested #ifdef/#endif.

Diff Detail

Event Timeline

gchatelet created this revision.Jul 17 2023, 2:23 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJul 17 2023, 2:23 PM
Herald added subscribers: libc-commits, luke, frasercrmck and 20 others. · View Herald Transcript
gchatelet requested review of this revision.Jul 17 2023, 2:23 PM
Herald added a subscriber: wangpc. · View Herald TranscriptJul 17 2023, 2:23 PM
gchatelet updated this revision to Diff 541237.Jul 17 2023, 2:36 PM
  • riscv does not have an optimzed memmove yet
Harbormaster completed remote builds in B246005: Diff 541237.Jul 17 2023, 3:52 PM
courbet accepted this revision.Jul 18 2023, 4:29 AM
This revision is now accepted and ready to land.Jul 18 2023, 4:29 AM
Closed by commit rG23dcdbfba790: [libc][NFC] Split memmove implementations per platform (authored by gchatelet). · Explain WhyJul 18 2023, 5:20 AM
This revision was automatically updated to reflect the committed changes.
gchatelet added a commit: rG23dcdbfba790: [libc][NFC] Split memmove implementations per platform.

Revision Contents

PathSize
libc/
src/
string/
memory_utils/
3 lines
aarch64/
51 lines
74 lines
riscv/
27 lines
x86_64/
36 lines
utils/
bazel/
llvm-project-overlay/
libc/
3 lines

Diff 541237

libc/src/string/memory_utils/CMakeLists.txt

# TODO(michaelrj): split out the implementations from memory_utils # TODO(michaelrj): split out the implementations from memory_utils
add_header_library( add_header_library(
memory_utils memory_utils
HDRS HDRS
aarch64/bcmp_implementations.h aarch64/bcmp_implementations.h
aarch64/memcmp_implementations.h aarch64/memcmp_implementations.h
aarch64/memcpy_implementations.h aarch64/memcpy_implementations.h
aarch64/memmove_implementations.h
aarch64/memset_implementations.h aarch64/memset_implementations.h
bcmp_implementations.h bcmp_implementations.h
bzero_implementations.h bzero_implementations.h
generic/aligned_access.h generic/aligned_access.h
generic/byte_per_byte.h generic/byte_per_byte.h
memcmp_implementations.h memcmp_implementations.h
memcpy_implementations.h memcpy_implementations.h
memmove_implementations.h memmove_implementations.h
memset_implementations.h memset_implementations.h
op_aarch64.h op_aarch64.h
op_builtin.h op_builtin.h
op_generic.h op_generic.h
op_x86.h op_x86.h
riscv/bcmp_implementations.h riscv/bcmp_implementations.h
riscv/memcmp_implementations.h riscv/memcmp_implementations.h
riscv/memcpy_implementations.h riscv/memcpy_implementations.h
riscv/memmove_implementations.h
riscv/memset_implementations.h riscv/memset_implementations.h
utils.h utils.h
x86_64/bcmp_implementations.h x86_64/bcmp_implementations.h
x86_64/memcmp_implementations.h x86_64/memcmp_implementations.h
x86_64/memcpy_implementations.h x86_64/memcpy_implementations.h
x86_64/memmove_implementations.h
x86_64/memset_implementations.h x86_64/memset_implementations.h
DEPS DEPS
libc.src.__support.common libc.src.__support.common
libc.src.__support.CPP.bit libc.src.__support.CPP.bit
libc.src.__support.CPP.cstddef libc.src.__support.CPP.cstddef
libc.src.__support.CPP.type_traits libc.src.__support.CPP.type_traits
libc.src.__support.macros.config libc.src.__support.macros.config
libc.src.__support.macros.optimization libc.src.__support.macros.optimization
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

libc/src/string/memory_utils/aarch64/memmove_implementations.h

  • This file was copied from libc/src/string/memory_utils/memmove_implementations.h.
//===-- Memmove implementation ----------------------------------*- C++ -*-===// //===-- Memmove implementation for aarch64 ----------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMMOVE_IMPLEMENTATIONS_H
#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMMOVE_IMPLEMENTATIONS_H
#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H #include "src/__support/macros/config.h" // LIBC_INLINE
#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H #include "src/string/memory_utils/op_aarch64.h" // aarch64::kNeon
#include "src/__support/common.h"
#include "src/__support/macros/optimization.h"
#include "src/string/memory_utils/generic/byte_per_byte.h"
#include "src/string/memory_utils/op_aarch64.h"
#include "src/string/memory_utils/op_builtin.h" #include "src/string/memory_utils/op_builtin.h"
#include "src/string/memory_utils/op_generic.h" #include "src/string/memory_utils/op_generic.h"
#include "src/string/memory_utils/op_x86.h" #include "src/string/memory_utils/utils.h"
#include <stddef.h> // size_t, ptrdiff_t
#include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
LIBC_INLINE void inline_memmove(Ptr dst, CPtr src, size_t count) { LIBC_INLINE void inline_memmove_aarch64(Ptr dst, CPtr src, size_t count) {
#if defined(LIBC_TARGET_ARCH_IS_X86) || defined(LIBC_TARGET_ARCH_IS_AARCH64)
#if defined(LIBC_TARGET_ARCH_IS_X86)
#if defined(__AVX512F__)
using uint128_t = generic_v128;
using uint256_t = generic_v256;
using uint512_t = generic_v512;
#elif defined(__AVX__)
using uint128_t = generic_v128;
using uint256_t = generic_v256;
using uint512_t = cpp::array<generic_v256, 2>;
#elif defined(__SSE2__)
using uint128_t = generic_v128;
using uint256_t = cpp::array<generic_v128, 2>;
using uint512_t = cpp::array<generic_v128, 4>;
#else
using uint128_t = cpp::array<uint64_t, 2>;
using uint256_t = cpp::array<uint64_t, 4>;
using uint512_t = cpp::array<uint64_t, 8>;
#endif
#elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
static_assert(aarch64::kNeon, "aarch64 supports vector types"); static_assert(aarch64::kNeon, "aarch64 supports vector types");
using uint128_t = generic_v128; using uint128_t = generic_v128;
using uint256_t = generic_v256; using uint256_t = generic_v256;
using uint512_t = generic_v512; using uint512_t = generic_v512;
#endif
if (count == 0) if (count == 0)
return; return;
if (count == 1) if (count == 1)
return generic::Memmove<uint8_t>::block(dst, src); return generic::Memmove<uint8_t>::block(dst, src);
if (count <= 4) if (count <= 4)
return generic::Memmove<uint16_t>::head_tail(dst, src, count); return generic::Memmove<uint16_t>::head_tail(dst, src, count);
if (count <= 8) if (count <= 8)
return generic::Memmove<uint32_t>::head_tail(dst, src, count); return generic::Memmove<uint32_t>::head_tail(dst, src, count);
if (count <= 16) if (count <= 16)
return generic::Memmove<uint64_t>::head_tail(dst, src, count); return generic::Memmove<uint64_t>::head_tail(dst, src, count);
if (count <= 32) if (count <= 32)
return generic::Memmove<uint128_t>::head_tail(dst, src, count); return generic::Memmove<uint128_t>::head_tail(dst, src, count);
if (count <= 64) if (count <= 64)
return generic::Memmove<uint256_t>::head_tail(dst, src, count); return generic::Memmove<uint256_t>::head_tail(dst, src, count);
if (count <= 128) if (count <= 128)
return generic::Memmove<uint512_t>::head_tail(dst, src, count); return generic::Memmove<uint512_t>::head_tail(dst, src, count);
if (dst < src) { if (dst < src) {
generic::Memmove<uint256_t>::align_forward<Arg::Src>(dst, src, count); generic::Memmove<uint256_t>::align_forward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_forward(dst, src, count); return generic::Memmove<uint512_t>::loop_and_tail_forward(dst, src, count);
} else { } else {
generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count); generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count); return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count);
} }
#else
return inline_memmove_byte_per_byte(dst, src, count);
#endif
}
LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src),
count);
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */ #endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMMOVE_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.h

  • This file was copied to libc/src/string/memory_utils/aarch64/memmove_implementations.h, libc/src/string/memory_utils/x86_64/memmove_implementations.h.
//===-- Memmove implementation ----------------------------------*- C++ -*-===// //===-- Memmove implementation ----------------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H #ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H
#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H
#include "src/__support/common.h"
#include "src/__support/macros/optimization.h"
#include "src/string/memory_utils/generic/byte_per_byte.h"
#include "src/string/memory_utils/op_aarch64.h"
#include "src/string/memory_utils/op_builtin.h"
#include "src/string/memory_utils/op_generic.h"
#include "src/string/memory_utils/op_x86.h"
#include <stddef.h> // size_t, ptrdiff_t #include <stddef.h> // size_t, ptrdiff_t
namespace __llvm_libc {
LIBC_INLINE void inline_memmove(Ptr dst, CPtr src, size_t count) {
#if defined(LIBC_TARGET_ARCH_IS_X86) || defined(LIBC_TARGET_ARCH_IS_AARCH64)
#if defined(LIBC_TARGET_ARCH_IS_X86) #if defined(LIBC_TARGET_ARCH_IS_X86)
#if defined(__AVX512F__) #include "src/string/memory_utils/x86_64/memmove_implementations.h"
using uint128_t = generic_v128; #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_x86
using uint256_t = generic_v256;
using uint512_t = generic_v512;
#elif defined(__AVX__)
using uint128_t = generic_v128;
using uint256_t = generic_v256;
using uint512_t = cpp::array<generic_v256, 2>;
#elif defined(__SSE2__)
using uint128_t = generic_v128;
using uint256_t = cpp::array<generic_v128, 2>;
using uint512_t = cpp::array<generic_v128, 4>;
#else
using uint128_t = cpp::array<uint64_t, 2>;
using uint256_t = cpp::array<uint64_t, 4>;
using uint512_t = cpp::array<uint64_t, 8>;
#endif
#elif defined(LIBC_TARGET_ARCH_IS_AARCH64) #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
static_assert(aarch64::kNeon, "aarch64 supports vector types"); #include "src/string/memory_utils/aarch64/memmove_implementations.h"
using uint128_t = generic_v128; #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_aarch64
using uint256_t = generic_v256; #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
using uint512_t = generic_v512; #include "src/string/memory_utils/riscv/memmove_implementations.h"
#endif #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_riscv
if (count == 0)
return;
if (count == 1)
return generic::Memmove<uint8_t>::block(dst, src);
if (count <= 4)
return generic::Memmove<uint16_t>::head_tail(dst, src, count);
if (count <= 8)
return generic::Memmove<uint32_t>::head_tail(dst, src, count);
if (count <= 16)
return generic::Memmove<uint64_t>::head_tail(dst, src, count);
if (count <= 32)
return generic::Memmove<uint128_t>::head_tail(dst, src, count);
if (count <= 64)
return generic::Memmove<uint256_t>::head_tail(dst, src, count);
if (count <= 128)
return generic::Memmove<uint512_t>::head_tail(dst, src, count);
if (dst < src) {
generic::Memmove<uint256_t>::align_forward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_forward(dst, src, count);
} else {
generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count);
}
#else #else
return inline_memmove_byte_per_byte(dst, src, count); // We may want to error instead of defaulting to suboptimal implementation.
#include "src/string/memory_utils/generic/byte_per_byte.h"
#define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_byte_per_byte
#endif #endif
}
namespace __llvm_libc {
LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) { LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src), LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE(reinterpret_cast<Ptr>(dst),
count); reinterpret_cast<CPtr>(src), count);
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */ #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/riscv/memmove_implementations.h

  • This file was added.
//===-- Memmove implementation for riscv ------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMMOVE_IMPLEMENTATIONS_H
#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMMOVE_IMPLEMENTATIONS_H
#include "src/__support/macros/attributes.h" // LIBC_INLINE
#include "src/__support/macros/properties/architectures.h" // LIBC_TARGET_ARCH_IS_RISCV64
#include "src/string/memory_utils/generic/byte_per_byte.h"
#include "src/string/memory_utils/utils.h" // Ptr, CPtr
#include <stddef.h> // size_t
namespace __llvm_libc {
[[maybe_unused]] LIBC_INLINE void
inline_memmove_riscv(Ptr __restrict dst, CPtr __restrict src, size_t count) {
return inline_memmove_byte_per_byte(dst, src, count);
}
} // namespace __llvm_libc
#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMMOVE_IMPLEMENTATIONS_H

libc/src/string/memory_utils/x86_64/memmove_implementations.h

  • This file was copied from libc/src/string/memory_utils/memmove_implementations.h.
//===-- Memmove implementation ----------------------------------*- C++ -*-===// //===-- Memmove implementation for x86_64 -----------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMMOVE_IMPLEMENTATIONS_H
#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMMOVE_IMPLEMENTATIONS_H
#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H #include "src/__support/macros/config.h" // LIBC_INLINE
#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H
#include "src/__support/common.h"
#include "src/__support/macros/optimization.h"
#include "src/string/memory_utils/generic/byte_per_byte.h"
#include "src/string/memory_utils/op_aarch64.h"
#include "src/string/memory_utils/op_builtin.h" #include "src/string/memory_utils/op_builtin.h"
#include "src/string/memory_utils/op_generic.h" #include "src/string/memory_utils/op_generic.h"
#include "src/string/memory_utils/op_x86.h" #include "src/string/memory_utils/op_x86.h"
#include <stddef.h> // size_t, ptrdiff_t #include "src/string/memory_utils/utils.h"
#include <stddef.h> // size_t
namespace __llvm_libc { namespace __llvm_libc {
LIBC_INLINE void inline_memmove(Ptr dst, CPtr src, size_t count) { LIBC_INLINE void inline_memmove_x86(Ptr dst, CPtr src, size_t count) {
#if defined(LIBC_TARGET_ARCH_IS_X86) || defined(LIBC_TARGET_ARCH_IS_AARCH64)
#if defined(LIBC_TARGET_ARCH_IS_X86)
#if defined(__AVX512F__) #if defined(__AVX512F__)
using uint128_t = generic_v128; using uint128_t = generic_v128;
using uint256_t = generic_v256; using uint256_t = generic_v256;
using uint512_t = generic_v512; using uint512_t = generic_v512;
#elif defined(__AVX__) #elif defined(__AVX__)
using uint128_t = generic_v128; using uint128_t = generic_v128;
using uint256_t = generic_v256; using uint256_t = generic_v256;
using uint512_t = cpp::array<generic_v256, 2>; using uint512_t = cpp::array<generic_v256, 2>;
#elif defined(__SSE2__) #elif defined(__SSE2__)
using uint128_t = generic_v128; using uint128_t = generic_v128;
using uint256_t = cpp::array<generic_v128, 2>; using uint256_t = cpp::array<generic_v128, 2>;
using uint512_t = cpp::array<generic_v128, 4>; using uint512_t = cpp::array<generic_v128, 4>;
#else #else
using uint128_t = cpp::array<uint64_t, 2>; using uint128_t = cpp::array<uint64_t, 2>;
using uint256_t = cpp::array<uint64_t, 4>; using uint256_t = cpp::array<uint64_t, 4>;
using uint512_t = cpp::array<uint64_t, 8>; using uint512_t = cpp::array<uint64_t, 8>;
#endif #endif
#elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
static_assert(aarch64::kNeon, "aarch64 supports vector types");
using uint128_t = generic_v128;
using uint256_t = generic_v256;
using uint512_t = generic_v512;
#endif
if (count == 0) if (count == 0)
return; return;
if (count == 1) if (count == 1)
return generic::Memmove<uint8_t>::block(dst, src); return generic::Memmove<uint8_t>::block(dst, src);
if (count <= 4) if (count <= 4)
return generic::Memmove<uint16_t>::head_tail(dst, src, count); return generic::Memmove<uint16_t>::head_tail(dst, src, count);
if (count <= 8) if (count <= 8)
return generic::Memmove<uint32_t>::head_tail(dst, src, count); return generic::Memmove<uint32_t>::head_tail(dst, src, count);
if (count <= 16) if (count <= 16)
return generic::Memmove<uint64_t>::head_tail(dst, src, count); return generic::Memmove<uint64_t>::head_tail(dst, src, count);
if (count <= 32) if (count <= 32)
return generic::Memmove<uint128_t>::head_tail(dst, src, count); return generic::Memmove<uint128_t>::head_tail(dst, src, count);
if (count <= 64) if (count <= 64)
return generic::Memmove<uint256_t>::head_tail(dst, src, count); return generic::Memmove<uint256_t>::head_tail(dst, src, count);
if (count <= 128) if (count <= 128)
return generic::Memmove<uint512_t>::head_tail(dst, src, count); return generic::Memmove<uint512_t>::head_tail(dst, src, count);
if (dst < src) { if (dst < src) {
generic::Memmove<uint256_t>::align_forward<Arg::Src>(dst, src, count); generic::Memmove<uint256_t>::align_forward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_forward(dst, src, count); return generic::Memmove<uint512_t>::loop_and_tail_forward(dst, src, count);
} else { } else {
generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count); generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count);
return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count); return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count);
} }
#else
return inline_memmove_byte_per_byte(dst, src, count);
#endif
}
LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src),
count);
} }
} // namespace __llvm_libc } // namespace __llvm_libc
#endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */ #endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMMOVE_IMPLEMENTATIONS_H

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

Show First 20 Lines • Show All 2,006 Lines • ▼ Show 20 Lines hdrs = [
"src/string/memory_utils/op_x86.h", "src/string/memory_utils/op_x86.h",
"src/string/memory_utils/utils.h", "src/string/memory_utils/utils.h",
], ],
defines = MEMORY_COPTS, defines = MEMORY_COPTS,
textual_hdrs = [ textual_hdrs = [
"src/string/memory_utils/aarch64/bcmp_implementations.h", "src/string/memory_utils/aarch64/bcmp_implementations.h",
"src/string/memory_utils/aarch64/memcmp_implementations.h", "src/string/memory_utils/aarch64/memcmp_implementations.h",
"src/string/memory_utils/aarch64/memcpy_implementations.h", "src/string/memory_utils/aarch64/memcpy_implementations.h",
"src/string/memory_utils/aarch64/memmove_implementations.h",
"src/string/memory_utils/aarch64/memset_implementations.h", "src/string/memory_utils/aarch64/memset_implementations.h",
"src/string/memory_utils/bcmp_implementations.h", "src/string/memory_utils/bcmp_implementations.h",
"src/string/memory_utils/bzero_implementations.h", "src/string/memory_utils/bzero_implementations.h",
"src/string/memory_utils/generic/aligned_access.h", "src/string/memory_utils/generic/aligned_access.h",
"src/string/memory_utils/generic/byte_per_byte.h", "src/string/memory_utils/generic/byte_per_byte.h",
"src/string/memory_utils/memcmp_implementations.h", "src/string/memory_utils/memcmp_implementations.h",
"src/string/memory_utils/memcpy_implementations.h", "src/string/memory_utils/memcpy_implementations.h",
"src/string/memory_utils/memmem_implementations.h", "src/string/memory_utils/memmem_implementations.h",
"src/string/memory_utils/memmove_implementations.h", "src/string/memory_utils/memmove_implementations.h",
"src/string/memory_utils/memset_implementations.h", "src/string/memory_utils/memset_implementations.h",
"src/string/memory_utils/riscv/bcmp_implementations.h", "src/string/memory_utils/riscv/bcmp_implementations.h",
"src/string/memory_utils/riscv/memcmp_implementations.h", "src/string/memory_utils/riscv/memcmp_implementations.h",
"src/string/memory_utils/riscv/memcpy_implementations.h", "src/string/memory_utils/riscv/memcpy_implementations.h",
"src/string/memory_utils/riscv/memmove_implementations.h",
"src/string/memory_utils/riscv/memset_implementations.h", "src/string/memory_utils/riscv/memset_implementations.h",
"src/string/memory_utils/strcmp_implementations.h", "src/string/memory_utils/strcmp_implementations.h",
"src/string/memory_utils/strstr_implementations.h", "src/string/memory_utils/strstr_implementations.h",
"src/string/memory_utils/x86_64/bcmp_implementations.h", "src/string/memory_utils/x86_64/bcmp_implementations.h",
"src/string/memory_utils/x86_64/memcmp_implementations.h", "src/string/memory_utils/x86_64/memcmp_implementations.h",
"src/string/memory_utils/x86_64/memcpy_implementations.h", "src/string/memory_utils/x86_64/memcpy_implementations.h",
"src/string/memory_utils/x86_64/memmove_implementations.h",
"src/string/memory_utils/x86_64/memset_implementations.h", "src/string/memory_utils/x86_64/memset_implementations.h",
], ],
deps = [ deps = [
":__support_common", ":__support_common",
":__support_cpp_array", ":__support_cpp_array",
":__support_cpp_bit", ":__support_cpp_bit",
":__support_cpp_cstddef", ":__support_cpp_cstddef",
":__support_cpp_type_traits", ":__support_cpp_type_traits",
▲ Show 20 Lines • Show All 684 Lines • Show Last 20 Lines