[libc][NFC] Move memfunction's byte per byte implementations to a separate header

[gchatelet]

Summary

There will be subsequent patches to move things around and make the file layout more principled.

libc/src/string/memory_utils/CMakeLists.txt

 #TODO(michaelrj): split out the implementations from memory_utils
 add_header_library(
   memory_utils
   HDRS
     aarch64/memcmp_implementations.h
     aarch64/memcpy_implementations.h
     bcmp_implementations.h
     bzero_implementations.h
+    generic/byte_per_byte.h
     memcmp_implementations.h
     memcpy_implementations.h
     memmove_implementations.h
     memset_implementations.h
     op_aarch64.h
     op_builtin.h
     op_generic.h
     op_x86.h

libc/src/string/memory_utils/bcmp_implementations.h

 //===-- Implementation of bcmp --------------------------------------------===//
 //
 // 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 LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H
 
 #include "src/__support/common.h"
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY LIBC_LOOP_NOUNROLL
 #include "src/__support/macros/properties/architectures.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_riscv.h"
 #include "src/string/memory_utils/op_x86.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE BcmpReturnType
-inline_bcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
-  return generic::Bcmp<uint8_t>::loop_and_tail_offset(p1, p2, count, offset);
-}
-
-[[maybe_unused]] LIBC_INLINE BcmpReturnType
 inline_bcmp_aligned_access_64bit(CPtr p1, CPtr p2, size_t count) {
   constexpr size_t kAlign = sizeof(uint64_t);
   if (count <= 2 * kAlign)
     return inline_bcmp_byte_per_byte(p1, p2, count);
   size_t bytes_to_p1_align = distance_to_align_up<kAlign>(p1);
   if (auto value = inline_bcmp_byte_per_byte(p1, p2, bytes_to_p1_align))
     return value;
   size_t offset = bytes_to_p1_align;

libc/src/string/memory_utils/generic/byte_per_byte.h

+//===-- Trivial byte per byte implementations  ----------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// Straightforward implementations targeting the smallest code size possible.
+// This needs to be compiled with '-Os' or '-Oz'.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_GENERIC_BYTE_PER_BYTE_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_GENERIC_BYTE_PER_BYTE_H
+
+#include "src/__support/macros/config.h"       // LIBC_INLINE
+#include "src/__support/macros/optimization.h" // LIBC_LOOP_NOUNROLL
+#include "src/string/memory_utils/utils.h"     // Ptr, CPtr
+
+#include <stddef.h> // size_t
+
+namespace __llvm_libc {
+
+[[maybe_unused]] LIBC_INLINE void
+inline_memcpy_byte_per_byte(Ptr dst, CPtr src, size_t count,
+                            size_t offset = 0) {
+  LIBC_LOOP_NOUNROLL
+  for (; offset < count; ++offset)
+    dst[offset] = src[offset];
+}
+
+[[maybe_unused]] LIBC_INLINE void
+inline_memmove_byte_per_byte(Ptr dst, CPtr src, size_t count) {
+  if (count == 0 || dst == src)
+    return;
+  if (dst < src) {
+    LIBC_LOOP_NOUNROLL
+    for (size_t offset = 0; offset < count; ++offset)
+      dst[offset] = src[offset];
+  } else {
+    LIBC_LOOP_NOUNROLL
+    for (ptrdiff_t offset = count - 1; offset >= 0; --offset)
+      dst[offset] = src[offset];
+  }
+}
+
+[[maybe_unused]] LIBC_INLINE static void
+inline_memset_byte_per_byte(Ptr dst, uint8_t value, size_t count,
+                            size_t offset = 0) {
+  LIBC_LOOP_NOUNROLL
+  for (; offset < count; ++offset)
+    dst[offset] = static_cast<cpp::byte>(value);
+}
+
+[[maybe_unused]] LIBC_INLINE BcmpReturnType
+inline_bcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
+  LIBC_LOOP_NOUNROLL
+  for (; offset < count; ++offset)
+    if (p1[offset] != p2[offset])
+      return BcmpReturnType::NONZERO();
+  return BcmpReturnType::ZERO();
+}
+
+[[maybe_unused]] LIBC_INLINE MemcmpReturnType
+inline_memcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
+  LIBC_LOOP_NOUNROLL
+  for (; offset < count; ++offset) {
+    const int32_t a = static_cast<int32_t>(p1[offset]);
+    const int32_t b = static_cast<int32_t>(p2[offset]);
+    const int32_t diff = a - b;
+    if (diff)
+      return diff;
+  }
+  return MemcmpReturnType::ZERO();
+}
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_GENERIC_BYTE_PER_BYTE_H

libc/src/string/memory_utils/memcmp_implementations.h

 //===-- Implementation of memcmp ------------------------------------------===//
 //
 // 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 LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H
 
 #include "src/__support/common.h"
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY LIBC_LOOP_NOUNROLL
 #include "src/__support/macros/properties/architectures.h"
+#include "src/string/memory_utils/generic/byte_per_byte.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/op_riscv.h"
 #include "src/string/memory_utils/utils.h" // CPtr MemcmpReturnType
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
 #include "src/string/memory_utils/x86_64/memcmp_implementations.h"
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memcmp_implementations.h"
 #endif
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE MemcmpReturnType
-inline_memcmp_byte_per_byte(CPtr p1, CPtr p2, size_t count, size_t offset = 0) {
-  return generic::Memcmp<uint8_t>::loop_and_tail_offset(p1, p2, count, offset);
-}
-
-[[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_aligned_access_64bit(CPtr p1, CPtr p2, size_t count) {
   constexpr size_t kAlign = sizeof(uint64_t);
   if (count <= 2 * kAlign)
     return inline_memcmp_byte_per_byte(p1, p2, count);
   size_t bytes_to_p1_align = distance_to_align_up<kAlign>(p1);
   if (auto value = inline_memcmp_byte_per_byte(p1, p2, bytes_to_p1_align))
     return value;
   size_t offset = bytes_to_p1_align;

libc/src/string/memory_utils/memcpy_implementations.h

 //===-- Memcpy implementation -----------------------------------*- 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 LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H
 
 #include "src/__support/macros/config.h"       // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_LOOP_NOUNROLL
 #include "src/__support/macros/properties/architectures.h"
+#include "src/string/memory_utils/generic/byte_per_byte.h"
 #include "src/string/memory_utils/op_builtin.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
 #include "src/string/memory_utils/x86_64/memcpy_implementations.h"
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "src/string/memory_utils/aarch64/memcpy_implementations.h"
 #endif
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE void
-inline_memcpy_byte_per_byte(Ptr dst, CPtr src, size_t offset, size_t count) {
-  LIBC_LOOP_NOUNROLL
-  for (; offset < count; ++offset)
-    dst[offset] = src[offset];
-}
-
-[[maybe_unused]] LIBC_INLINE void
 inline_memcpy_aligned_access_32bit(Ptr __restrict dst, CPtr __restrict src,
                                    size_t count) {
   constexpr size_t kAlign = sizeof(uint32_t);
   if (count <= 2 * kAlign)
-    return inline_memcpy_byte_per_byte(dst, src, 0, count);
+    return inline_memcpy_byte_per_byte(dst, src, count);
   size_t bytes_to_dst_align = distance_to_align_up<kAlign>(dst);
-  inline_memcpy_byte_per_byte(dst, src, 0, bytes_to_dst_align);
+  inline_memcpy_byte_per_byte(dst, src, bytes_to_dst_align);
   size_t offset = bytes_to_dst_align;
   size_t src_alignment = distance_to_align_down<kAlign>(src + offset);
   for (; offset < count - kAlign; offset += kAlign) {
     uint32_t value;
     if (src_alignment == 0)
       value = load32_aligned<uint32_t>(src, offset);
     else if (src_alignment == 2)
       value = load32_aligned<uint16_t, uint16_t>(src, offset);
     else
       value = load32_aligned<uint8_t, uint16_t, uint8_t>(src, offset);
     store32_aligned<uint32_t>(value, dst, offset);
   }
   // remainder
-  inline_memcpy_byte_per_byte(dst, src, offset, count);
+  inline_memcpy_byte_per_byte(dst, src, count, offset);
 }
 
 [[maybe_unused]] LIBC_INLINE void
 inline_memcpy_aligned_access_64bit(Ptr __restrict dst, CPtr __restrict src,
                                    size_t count) {
   constexpr size_t kAlign = sizeof(uint64_t);
   if (count <= 2 * kAlign)
-    return inline_memcpy_byte_per_byte(dst, src, 0, count);
+    return inline_memcpy_byte_per_byte(dst, src, count);
   size_t bytes_to_dst_align = distance_to_align_up<kAlign>(dst);
-  inline_memcpy_byte_per_byte(dst, src, 0, bytes_to_dst_align);
+  inline_memcpy_byte_per_byte(dst, src, bytes_to_dst_align);
   size_t offset = bytes_to_dst_align;
   size_t src_alignment = distance_to_align_down<kAlign>(src + offset);
   for (; offset < count - kAlign; offset += kAlign) {
     uint64_t value;
     if (src_alignment == 0)
       value = load64_aligned<uint64_t>(src, offset);
     else if (src_alignment == 4)
       value = load64_aligned<uint32_t, uint32_t>(src, offset);
     else if (src_alignment == 2)
       value =
           load64_aligned<uint16_t, uint16_t, uint16_t, uint16_t>(src, offset);
     else
       value = load64_aligned<uint8_t, uint16_t, uint16_t, uint16_t, uint8_t>(
           src, offset);
     store64_aligned<uint64_t>(value, dst, offset);
   }
   // remainder
-  inline_memcpy_byte_per_byte(dst, src, offset, count);
+  inline_memcpy_byte_per_byte(dst, src, count, offset);
 }
 
 LIBC_INLINE void inline_memcpy(Ptr __restrict dst, CPtr __restrict src,
                                size_t count) {
   using namespace __llvm_libc::builtin;
 #if defined(LIBC_COPT_MEMCPY_USE_EMBEDDED_TINY)
-  return inline_memcpy_byte_per_byte(dst, src, 0, count);
+  return inline_memcpy_byte_per_byte(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_X86)
   return inline_memcpy_x86_maybe_interpose_repmovsb(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   return inline_memcpy_aarch64(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
   return inline_memcpy_aligned_access_64bit(dst, src, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV32)
   return inline_memcpy_aligned_access_32bit(dst, src, count);
 #else
-  return inline_memcpy_byte_per_byte(dst, src, 0, count);
+  return inline_memcpy_byte_per_byte(dst, src, count);
 #endif
 }
 
 LIBC_INLINE void inline_memcpy(void *__restrict dst, const void *__restrict src,
                                size_t count) {
   inline_memcpy(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.h

 //===-- Memmove implementation ----------------------------------*- 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 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
 
 namespace __llvm_libc {
 
-[[maybe_unused]] LIBC_INLINE void
-inline_memmove_embedded_tiny(Ptr dst, CPtr src, size_t count) {
-  if ((count == 0) || (dst == src))
-    return;
-  if (dst < src) {
-    LIBC_LOOP_NOUNROLL
-    for (size_t offset = 0; offset < count; ++offset)
-      builtin::Memcpy<1>::block(dst + offset, src + offset);
-  } else {
-    LIBC_LOOP_NOUNROLL
-    for (ptrdiff_t offset = count - 1; offset >= 0; --offset)
-      builtin::Memcpy<1>::block(dst + offset, src + offset);
-  }
-}
-
 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(__AVX512F__)
   using uint128_t = generic_v128;
   using uint256_t = generic_v256;
   using uint512_t = generic_v512;
 #elif defined(__AVX__)
#endif
   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
-  return inline_memmove_embedded_tiny(dst, src, count);
+  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
 
 #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/memset_implementations.h

 //===-- Implementation of memset and bzero --------------------------------===//
 //
 // 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 LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H
 #define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H
 
 #include "src/__support/common.h"
 #include "src/__support/macros/optimization.h"
 #include "src/__support/macros/properties/architectures.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 "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE static void
-inline_memset_byte_per_byte(Ptr dst, size_t offset, uint8_t value,
-                            size_t count) {
-  LIBC_LOOP_NOUNROLL
-  for (; offset < count; ++offset)
-    generic::Memset<uint8_t>::block(dst + offset, value);
-}
-
-[[maybe_unused]] LIBC_INLINE static void
 inline_memset_aligned_access_32bit(Ptr dst, uint8_t value, size_t count) {
   constexpr size_t kAlign = sizeof(uint32_t);
   if (count <= 2 * kAlign)
-    return inline_memset_byte_per_byte(dst, 0, value, count);
+    return inline_memset_byte_per_byte(dst, value, count);
   size_t bytes_to_dst_align = distance_to_align_up<kAlign>(dst);
-  inline_memset_byte_per_byte(dst, 0, value, bytes_to_dst_align);
+  inline_memset_byte_per_byte(dst, value, bytes_to_dst_align);
   size_t offset = bytes_to_dst_align;
   for (; offset < count - kAlign; offset += kAlign)
     store32_aligned<uint32_t>(generic::splat<uint32_t>(value), dst, offset);
-  inline_memset_byte_per_byte(dst, offset, value, count);
+  inline_memset_byte_per_byte(dst, value, count, offset);
 }
 
 [[maybe_unused]] LIBC_INLINE static void
 inline_memset_aligned_access_64bit(Ptr dst, uint8_t value, size_t count) {
   constexpr size_t kAlign = sizeof(uint64_t);
   if (count <= 2 * kAlign)
-    return inline_memset_byte_per_byte(dst, 0, value, count);
+    return inline_memset_byte_per_byte(dst, value, count);
   size_t bytes_to_dst_align = distance_to_align_up<kAlign>(dst);
-  inline_memset_byte_per_byte(dst, 0, value, bytes_to_dst_align);
+  inline_memset_byte_per_byte(dst, value, bytes_to_dst_align);
   size_t offset = bytes_to_dst_align;
   for (; offset < count - kAlign; offset += kAlign)
     store64_aligned<uint64_t>(generic::splat<uint64_t>(value), dst, offset);
-  inline_memset_byte_per_byte(dst, offset, value, count);
+  inline_memset_byte_per_byte(dst, value, count, offset);
 }
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
 [[maybe_unused]] LIBC_INLINE static void
 inline_memset_x86(Ptr dst, uint8_t value, size_t count) {
 #if defined(__AVX512F__)
   using uint128_t = generic_v128;
   using uint256_t = generic_v256;
#if defined(LIBC_TARGET_ARCH_IS_X86)
   return inline_memset_x86(dst, value, count);
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
   return inline_memset_aarch64(dst, value, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
   return inline_memset_aligned_access_64bit(dst, value, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV32)
   return inline_memset_aligned_access_32bit(dst, value, count);
 #else
-  return inline_memset_byte_per_byte(dst, 0, value, count);
+  return inline_memset_byte_per_byte(dst, value, count);
 #endif
 }
 
 LIBC_INLINE static void inline_memset(void *dst, uint8_t value, size_t count) {
   inline_memset(reinterpret_cast<Ptr>(dst), value, count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H

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

hdrs = [
         "src/string/memory_utils/utils.h",
     ],
     defines = MEMORY_COPTS,
     textual_hdrs = [
         "src/string/memory_utils/aarch64/memcmp_implementations.h",
         "src/string/memory_utils/aarch64/memcpy_implementations.h",
         "src/string/memory_utils/bcmp_implementations.h",
         "src/string/memory_utils/bzero_implementations.h",
+        "src/string/memory_utils/generic/byte_per_byte.h",
         "src/string/memory_utils/memcmp_implementations.h",
         "src/string/memory_utils/memcpy_implementations.h",
+        "src/string/memory_utils/memmem_implementations.h",
         "src/string/memory_utils/memmove_implementations.h",
         "src/string/memory_utils/memset_implementations.h",
         "src/string/memory_utils/strcmp_implementations.h",
         "src/string/memory_utils/strstr_implementations.h",
-        "src/string/memory_utils/memmem_implementations.h",
         "src/string/memory_utils/x86_64/memcmp_implementations.h",
         "src/string/memory_utils/x86_64/memcpy_implementations.h",
     ],
     deps = [
         ":__support_common",
         ":__support_cpp_array",
         ":__support_cpp_bit",
         ":__support_cpp_cstddef",