[libc][NFC] Rename files

[gchatelet]

Summary

This patch mostly renames files so it better reflects the function they declare.

[gchatelet]

• Adding inline_strncmp as well

[michaelrj]

LGTM

[gchatelet]

rebase

[gchatelet]

Thx @michaelrj for the review.

libc/src/__support/CPP/CMakeLists.txt

add_header_library(
   string
   HDRS
     string.h
   DEPENDS
     libc.include.stdlib
     .string_view
     libc.src.__support.common
     libc.src.__support.integer_to_string
-    libc.src.string.memory_utils.memcpy_implementation
-    libc.src.string.memory_utils.memset_implementation
+    libc.src.string.memory_utils.inline_memcpy
+    libc.src.string.memory_utils.inline_memset
     libc.src.string.string_utils
 )
 
 add_header_library(
   stringstream
   HDRS
     stringstream.h
   DEPENDS

libc/src/__support/CPP/string.h

 //===-- A simple implementation of the string class -------------*- 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_SUPPORT_CPP_STRING_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_STRING_H
 
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/integer_to_string.h" // IntegerToString
-#include "src/string/memory_utils/memcpy_implementations.h"
-#include "src/string/memory_utils/memset_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
+#include "src/string/memory_utils/inline_memset.h"
 #include "src/string/string_utils.h" // string_length
 
 #include <stddef.h> // size_t
 #include <stdlib.h> // malloc, free
 
 namespace __llvm_libc {
 namespace cpp {
 

libc/src/__support/OSUtil/gpu/CMakeLists.txt

 add_object_library(
   gpu_util
   SRCS
     quick_exit.cpp
     io.cpp
   HDRS
     quick_exit.h
     io.h
   DEPENDS
     libc.src.__support.common
     libc.src.__support.CPP.string_view
     libc.src.__support.RPC.rpc_client
-    libc.src.string.memory_utils.memcpy_implementation
+    libc.src.string.memory_utils.inline_memcpy
 )

libc/src/__support/OSUtil/gpu/io.cpp

 //===-------------- GPU implementation of IO utils --------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "io.h"
 
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/RPC/rpc_client.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
 
 namespace __llvm_libc {
 
 void write_to_stderr(cpp::string_view msg) {
   rpc::Client::Port port = rpc::client.open<RPC_WRITE_TO_STDERR>();
   port.send_n(msg.data(), msg.size());
   port.recv([](rpc::Buffer *) { /* void */ });
   port.close();
 }
 
 } // namespace __llvm_libc

libc/src/__support/RPC/rpc.h

 #ifndef LLVM_LIBC_SRC_SUPPORT_RPC_RPC_H
 #define LLVM_LIBC_SRC_SUPPORT_RPC_RPC_H
 
 #include "rpc_util.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/functional.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/GPU/utils.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace rpc {
 
 /// A fixed size channel used to communicate between the RPC client and server.
 struct Buffer {

libc/src/stdio/printf_core/CMakeLists.txt

 
 add_object_library(
   string_writer
   SRCS
     string_writer.cpp
   HDRS
     string_writer.h
   DEPENDS
-    libc.src.__support.CPP.string_view
-    libc.src.string.memory_utils.memcpy_implementation
-    libc.src.string.memory_utils.memset_implementation
     .core_structs
+    libc.src.__support.CPP.string_view
+    libc.src.string.memory_utils.inline_memcpy
+    libc.src.string.memory_utils.inline_memset
 )
 
 add_object_library(
   writer
   SRCS
     writer.cpp
   HDRS
     writer.h
if(NOT (TARGET libc.src.__support.File.file) AND LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 add_header_library(
   file_writer
   HDRS
     file_writer.h
   DEPENDS
+    .core_structs
     libc.include.stdio
-    libc.src.__support.File.file
     libc.src.__support.CPP.string_view
-    libc.src.string.memory_utils.memset_implementation
-    .core_structs
+    libc.src.__support.File.file
+    libc.src.string.memory_utils.inline_memset
 )
 
 add_header_library(
   vfprintf_internal
   HDRS
     vfprintf_internal.h
   DEPENDS
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.arg_list
     libc.src.stdio.printf_core.printf_main
     libc.src.stdio.printf_core.file_writer
     libc.src.stdio.printf_core.writer
 )

libc/src/stdio/printf_core/string_writer.h

 //===-- String Writer definition for printf ---------------------*- 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_STDIO_PRINTF_CORE_STRING_WRITER_H
 #define LLVM_LIBC_SRC_STDIO_PRINTF_CORE_STRING_WRITER_H
 
 #include "src/__support/CPP/string_view.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 class StringWriter {
   char *__restrict cur_buffer;
   size_t available_capacity;

libc/src/stdio/printf_core/string_writer.cpp

 //===-- String Writer implementation for printf -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdio/printf_core/string_writer.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/stdio/printf_core/core_structs.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
-#include "src/string/memory_utils/memset_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
+#include "src/string/memory_utils/inline_memset.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 void StringWriter::write(cpp::string_view new_string) {
   size_t len = new_string.size();
   if (len > available_capacity)

libc/src/string/CMakeLists.txt

 add_subdirectory(memory_utils)
 
 add_header_library(
   string_utils
   HDRS
     string_utils.h
   DEPENDS
+    .memory_utils.inline_bzero
+    .memory_utils.inline_memcpy
     libc.include.stdlib
-    libc.src.__support.CPP.bitset
     libc.src.__support.common
-    .memory_utils.memcpy_implementation
-    .memory_utils.bzero_implementation
+    libc.src.__support.CPP.bitset
 )
 
 add_header_library(
   allocating_string_utils
   HDRS
     allocating_string_utils.h
   DEPENDS
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
     libc.include.stdlib
     libc.src.__support.CPP.optional
     libc.src.__support.macros.config
 )
 
 add_entrypoint_object(
   bcopy
   SRCS

 
 add_entrypoint_object(
   mempcpy
   SRCS
     mempcpy.cpp
   HDRS
     mempcpy.h
   DEPENDS
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
 )
 
 add_entrypoint_object(
   memmem
   SRCS
     memmem.cpp
   HDRS
     memmem.h
   DEPENDS
-    .memory_utils.memmem_implementation
+    .memory_utils.inline_memmem
 )
 
 add_entrypoint_object(
   memchr
   SRCS
     memchr.cpp
   HDRS
     memchr.h

 
 add_entrypoint_object(
   stpncpy
   SRCS
     stpncpy.cpp
   HDRS
     stpncpy.h
   DEPENDS
-    .memory_utils.bzero_implementation
+    .memory_utils.inline_bzero
 )
 
 add_entrypoint_object(
   strcat
   SRCS
     strcat.cpp
   HDRS
     strcat.h

 
 add_entrypoint_object(
   strcmp
   SRCS
     strcmp.cpp
   HDRS
     strcmp.h
   DEPENDS
-    .memory_utils.strcmp_implementation
+    .memory_utils.inline_strcmp
 )
 
 add_entrypoint_object(
   strcasecmp
   SRCS
     strcasecmp.cpp
   HDRS
     strcasecmp.h
   DEPENDS
-    .memory_utils.strcmp_implementation
+    .memory_utils.inline_strcmp
     libc.src.__support.ctype_utils
 )
 
 add_entrypoint_object(
   strcasestr
   SRCS
     strcasestr.cpp
   HDRS
     strcasestr.h
   DEPENDS
-    .memory_utils.strstr_implementation
+    .memory_utils.inline_strstr
     libc.src.__support.ctype_utils
 )
 
 add_entrypoint_object(
   strcoll
   SRCS
     strcoll.cpp
   HDRS
     strcoll.h
 )
 
 add_entrypoint_object(
   strcpy
   SRCS
     strcpy.cpp
   HDRS
     strcpy.h
   DEPENDS
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
     .string_utils
 )
 
 add_entrypoint_object(
   strcspn
   SRCS
     strcspn.cpp
   HDRS
     strcspn.h
   DEPENDS
     .string_utils
 )
 
 add_entrypoint_object(
   strdup
   SRCS
     strdup.cpp
   HDRS
     strdup.h
   DEPENDS
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
     .string_utils
     libc.include.stdlib
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   strerror
   SRCS

 
 add_entrypoint_object(
   strncmp
   SRCS
     strncmp.cpp
   HDRS
     strncmp.h
   DEPENDS
-    .memory_utils.strcmp_implementation
+    .memory_utils.inline_strcmp
 )
 
 add_entrypoint_object(
   strncasecmp
   SRCS
     strncasecmp.cpp
   HDRS
     strncasecmp.h
   DEPENDS
-    .memory_utils.strcmp_implementation
+    .memory_utils.inline_strcmp
     libc.src.__support.ctype_utils
 )
 
 add_entrypoint_object(
   strncpy
   SRCS
     strncpy.cpp
   HDRS
     strncpy.h
 )
 
 add_entrypoint_object(
   strndup
   SRCS
     strndup.cpp
   HDRS
     strndup.h
   DEPENDS
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
     .string_utils
     libc.include.stdlib
     libc.src.__support.CPP.new
 )
 
 add_entrypoint_object(
   strnlen
   SRCS

 
 add_entrypoint_object(
   strstr
   SRCS
     strstr.cpp
   HDRS
     strstr.h
   DEPENDS
-    .memory_utils.strstr_implementation
+    .memory_utils.inline_strstr
 )
 
 add_entrypoint_object(
   strtok
   SRCS
     strtok.cpp
   HDRS
     strtok.h

 add_entrypoint_object(
   strxfrm
   SRCS
     strxfrm.cpp
   HDRS
     strxfrm.h
   DEPENDS
     .string_utils
-    .memory_utils.memcpy_implementation
+    .memory_utils.inline_memcpy
 )
 
 # Helper to define a function with multiple implementations
 # - Computes flags to satisfy required/rejected features and arch,
 # - Declares an entry point,
 # - Attach the REQUIRE_CPU_FEATURES property to the target,
 # - Add the fully qualified target to `${name}_implementations` global property for tests.
 function(add_implementation name impl_name)

 # bzero
 # ------------------------------------------------------------------------------
 
 function(add_bzero bzero_name)
   add_implementation(bzero ${bzero_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/bzero.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/bzero.h
     DEPENDS
-      .memory_utils.memset_implementation
+      .memory_utils.inline_memset
       libc.include.string
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_bzero(bzero_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_bzero(bzero_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)

 # memcmp
 # ------------------------------------------------------------------------------
 
 function(add_memcmp memcmp_name)
   add_implementation(memcmp ${memcmp_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memcmp.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memcmp.h
     DEPENDS
-      .memory_utils.memcmp_implementation
+      .memory_utils.inline_memcmp
       libc.include.string
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memcmp(memcmp_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memcmp(memcmp_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)

 # memcpy
 # ------------------------------------------------------------------------------
 
 function(add_memcpy memcpy_name)
   add_implementation(memcpy ${memcpy_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memcpy.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memcpy.h
     DEPENDS
-      .memory_utils.memcpy_implementation
+      .memory_utils.inline_memcpy
       libc.include.string
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memcpy(memcpy_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memcpy(memcpy_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)

 # memmove
 # ------------------------------------------------------------------------------
 
 function(add_memmove memmove_name)
   add_implementation(memmove ${memmove_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memmove.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memmove.h
     DEPENDS
-      .memory_utils.memcpy_implementation
+      .memory_utils.inline_memcpy
       libc.include.string
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memmove(memmove_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memmove(memmove_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)

 # memset
 # ------------------------------------------------------------------------------
 
 function(add_memset memset_name)
   add_implementation(memset ${memset_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memset.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memset.h
     DEPENDS
-      .memory_utils.memset_implementation
+      .memory_utils.inline_memset
       libc.include.string
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memset(memset_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memset(memset_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)

libc/src/string/allocating_string_utils.h

 //===-- Allocating string utils ---------------------------------*- 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_ALLOCATING_STRING_UTILS_H
 #define LIBC_SRC_STRING_ALLOCATING_STRING_UTILS_H
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/macros/config.h"
-#include "src/string/memory_utils/memcpy_implementations.h" // For string_length
+#include "src/string/memory_utils/inline_memcpy.h"
 #include "src/string/string_utils.h"
 
 #include <stddef.h> // For size_t
 
 namespace __llvm_libc {
 namespace internal {
 
 LIBC_INLINE cpp::optional<char *> strdup(const char *src) {

libc/src/string/bcmp.cpp

 //===-- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/bcmp.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/bcmp_implementations.h"
+#include "src/string/memory_utils/inline_bcmp.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, bcmp,
                    (const void *lhs, const void *rhs, size_t count)) {
   return inline_bcmp(lhs, rhs, count);
 }
 
 } // namespace __llvm_libc

libc/src/string/bcopy.cpp

 //===-- Implementation of bcopy -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/bcopy.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memmove_implementations.h"
+#include "src/string/memory_utils/inline_memmove.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void, bcopy, (const void *src, void *dst, size_t count)) {
   return inline_memmove(dst, src, count);
 }
 
 } // namespace __llvm_libc

libc/src/string/bzero.cpp

 //===-- Implementation of 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/bzero.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/bzero_implementations.h"
+#include "src/string/memory_utils/inline_bzero.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void, bzero, (void *ptr, size_t count)) {
   inline_bzero(reinterpret_cast<char *>(ptr), count);
 }
 
 } // namespace __llvm_libc

libc/src/string/memcmp.cpp

 //===-- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memcmp.h"
-#include "src/string/memory_utils/memcmp_implementations.h"
+#include "src/string/memory_utils/inline_memcmp.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, memcmp,
                    (const void *lhs, const void *rhs, size_t count)) {
   return inline_memcmp(lhs, rhs, count);
 }
 
 } // namespace __llvm_libc

libc/src/string/memcpy.cpp

 //===-- Implementation of memcpy ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memcpy.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memcpy,
                    (void *__restrict dst, const void *__restrict src,
                     size_t size)) {
   inline_memcpy(dst, src, size);
   return dst;
 }
 
 } // namespace __llvm_libc

libc/src/string/memmem.cpp

 //===-- Implementation of memmem ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memmem.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memmem_implementations.h"
+#include "src/string/memory_utils/inline_memmem.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memmem,
                    (const void *haystack, size_t haystack_len,
                     const void *needle, size_t needle_len)) {
   constexpr auto comp = [](unsigned char l, unsigned char r) -> int {
     return l - r;
   };
-  return memmem_implementation(haystack, haystack_len, needle, needle_len,
-                               comp);
+  return inline_memmem(haystack, haystack_len, needle, needle_len, comp);
 }
 
 } // namespace __llvm_libc

libc/src/string/memmove.cpp

 //===-- Implementation of memmove -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memmove.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
-#include "src/string/memory_utils/memmove_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
+#include "src/string/memory_utils/inline_memmove.h"
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memmove,
                    (void *dst, const void *src, size_t count)) {
   if (is_disjoint(dst, src, count))
     inline_memcpy(dst, src, count);
   else
     inline_memmove(dst, src, count);
   return dst;
 }
 
 } // namespace __llvm_libc

libc/src/string/memory_utils/CMakeLists.txt

 # TODO(michaelrj): split out the implementations from memory_utils
 add_header_library(
   memory_utils
   HDRS
-    aarch64/bcmp_implementations.h
-    aarch64/memcmp_implementations.h
-    aarch64/memcpy_implementations.h
-    aarch64/memmove_implementations.h
-    aarch64/memset_implementations.h
-    bcmp_implementations.h
-    bzero_implementations.h
+    aarch64/inline_bcmp.h
+    aarch64/inline_memcmp.h
+    aarch64/inline_memcpy.h
+    aarch64/inline_memmove.h
+    aarch64/inline_memset.h
     generic/aligned_access.h
     generic/byte_per_byte.h
-    memcmp_implementations.h
-    memcpy_implementations.h
-    memmove_implementations.h
-    memset_implementations.h
+    inline_bcmp.h
+    inline_bzero.h
+    inline_memcmp.h
+    inline_memcpy.h
+    inline_memmove.h
+    inline_memset.h
     op_aarch64.h
     op_builtin.h
     op_generic.h
     op_x86.h
-    riscv/bcmp_implementations.h
-    riscv/memcmp_implementations.h
-    riscv/memcpy_implementations.h
-    riscv/memmove_implementations.h
-    riscv/memset_implementations.h
+    riscv/inline_bcmp.h
+    riscv/inline_memcmp.h
+    riscv/inline_memcpy.h
+    riscv/inline_memmove.h
+    riscv/inline_memset.h
     utils.h
-    x86_64/bcmp_implementations.h
-    x86_64/memcmp_implementations.h
-    x86_64/memcpy_implementations.h
-    x86_64/memmove_implementations.h
-    x86_64/memset_implementations.h
+    x86_64/inline_bcmp.h
+    x86_64/inline_memcmp.h
+    x86_64/inline_memcpy.h
+    x86_64/inline_memmove.h
+    x86_64/inline_memset.h
   DEPS
     libc.src.__support.common
     libc.src.__support.CPP.bit
     libc.src.__support.CPP.cstddef
     libc.src.__support.CPP.type_traits
     libc.src.__support.macros.config
     libc.src.__support.macros.optimization
     libc.src.__support.macros.properties.architectures
 )
 
 add_header_library(
-  memcpy_implementation
+  inline_memcpy
   HDRS
-    memcpy_implementations.h
+    inline_memcpy.h
   DEPS
     .memory_utils
 )
 
 add_header_library(
-  memmove_implementation
+  inline_memmove
   HDRS
-    memmove_implementations.h
+    inline_memmove.h
   DEPS
     .memory_utils
 )
 
 add_header_library(
-  memcmp_implementation
+  inline_memcmp
   HDRS
-    memcmp_implementations.h
+    inline_memcmp.h
   DEPS
     .memory_utils
 )
 
 add_header_library(
-  memset_implementation
+  inline_memset
   HDRS
-    memset_implementations.h
+    inline_memset.h
   DEPS
     .memory_utils
 )
 
 add_header_library(
-  bzero_implementation
+  inline_bzero
   HDRS
-    bzero_implementations.h
+    inline_bzero.h
   DEPS
-    .memset_implementation
+    .inline_memset
 )
 
 add_header_library(
-  strcmp_implementation
+  inline_strcmp
   HDRS
-    strcmp_implementations.h
+    inline_strcmp.h
 )
 
 add_header_library(
- strstr_implementation
+  inline_strstr
   HDRS
-    strstr_implementations.h
+    inline_strstr.h
 )
 
 add_header_library(
-  memmem_implementation
+  inline_memmem
   HDRS
-    memmem_implementations.h
+    inline_memmem.h
 )

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

 //===-- Bcmp implementation for aarch64 -------------------------*- 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_AARCH64_BCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_BCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_BCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_BCMP_H
 
 #include "src/__support/macros/attributes.h"   // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/op_aarch64.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
if (auto value = aarch64::Bcmp<32>::block(p1, p2))
       return value;
     align_to_next_boundary<16, Arg::P1>(p1, p2, count);
   }
   return aarch64::Bcmp<32>::loop_and_tail(p1, p2, count);
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_BCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_BCMP_H

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

 //===-- Memcmp implementation for aarch64 -----------------------*- 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_X86_64_MEMCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H
 
 #include "src/__support/macros/config.h"       // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/op_aarch64.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/utils.h" // MemcmpReturnType
 
 namespace __llvm_libc {
if (count <= 16)
     return generic::Memcmp<uint64_t>::head_tail(p1, p2, count);
   if constexpr (aarch64::kNeon)
     return inline_memcmp_aarch64_neon_gt16(p1, p2, count);
   else
     return inline_memcmp_generic_gt16(p1, p2, count);
 }
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H

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

 //===-- Memcpy implementation for aarch64 -----------------------*- 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_AARCH64_MEMCPY_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMCPY_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMCPY_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMCPY_H
 
 #include "src/__support/macros/config.h" // LIBC_INLINE
 #include "src/string/memory_utils/op_builtin.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
if (count < 128)
     return builtin::Memcpy<64>::head_tail(dst, src, count);
   builtin::Memcpy<16>::block(dst, src);
   align_to_next_boundary<16, Arg::Src>(dst, src, count);
   return builtin::Memcpy<64>::loop_and_tail(dst, src, count);
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMCPY_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMCPY_H

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

 //===-- Memmove implementation for aarch64 ----------------------*- 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_AARCH64_MEMMOVE_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMMOVE_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMMOVE_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMMOVE_H
 
 #include "src/__support/macros/config.h"        // LIBC_INLINE
 #include "src/string/memory_utils/op_aarch64.h" // aarch64::kNeon
 #include "src/string/memory_utils/op_builtin.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/utils.h"
 
 #include <stddef.h> // size_t
LIBC_INLINE void inline_memmove_aarch64(Ptr dst, CPtr src, size_t 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);
   }
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMMOVE_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMMOVE_H

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

 //===-- Memset implementation for aarch64 -----------------------*- 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_AARCH64_MEMSET_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMSET_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMSET_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMSET_H
 
 #include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/string/memory_utils/op_aarch64.h"
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
if (count >= 448 && value == 0 && aarch64::neon::hasZva()) {
     generic::Memset<uint128_t>::block(dst, value);
     align_to_next_boundary<16>(dst, count);
     return generic::Memset<uint512_t>::loop_and_tail(dst, value, count);
   }
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_MEMSET_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_AARCH64_INLINE_MEMSET_H

libc/src/string/memory_utils/inline_bcmp.h

 //===-- Dispatch logic for 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
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BCMP_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BCMP_H
 
 #include "src/__support/common.h"
 #include "src/__support/macros/properties/architectures.h" // LIBC_TARGET_ARCH_IS_
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
-#include "src/string/memory_utils/x86_64/bcmp_implementations.h"
+#include "src/string/memory_utils/x86_64/inline_bcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
-#include "src/string/memory_utils/aarch64/bcmp_implementations.h"
+#include "src/string/memory_utils/aarch64/inline_bcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-#include "src/string/memory_utils/riscv/bcmp_implementations.h"
+#include "src/string/memory_utils/riscv/inline_bcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_riscv
 #elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_BCMP inline_bcmp_byte_per_byte
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE int inline_bcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(LIBC_SRC_STRING_MEMORY_UTILS_BCMP(
       reinterpret_cast<CPtr>(p1), reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_BCMP
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BCMP_H

libc/src/string/memory_utils/inline_bzero.h

 //===-- Implementation of 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_BZERO_IMPLEMENTATIONS_H
-#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BZERO_IMPLEMENTATIONS_H
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BZERO_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BZERO_H
 
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memset_implementations.h"
+#include "src/string/memory_utils/inline_memset.h"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 LIBC_INLINE static void inline_bzero(Ptr dst, size_t count) {
   inline_memset(dst, 0, count);
 }
 
 LIBC_INLINE static void inline_bzero(void *dst, size_t count) {
   inline_bzero(reinterpret_cast<Ptr>(dst), count);
 }
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BZERO_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_BZERO_H

libc/src/string/memory_utils/inline_memcmp.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
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCMP_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCMP_H
 
 #include "src/__support/macros/config.h"                   // LIBC_INLINE
 #include "src/__support/macros/properties/architectures.h" // LIBC_TARGET_ARCH_IS_
 #include "src/string/memory_utils/utils.h"                 // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
-#include "src/string/memory_utils/x86_64/memcmp_implementations.h"
+#include "src/string/memory_utils/x86_64/inline_memcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
-#include "src/string/memory_utils/aarch64/memcmp_implementations.h"
+#include "src/string/memory_utils/aarch64/inline_memcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-#include "src/string/memory_utils/riscv/memcmp_implementations.h"
+#include "src/string/memory_utils/riscv/inline_memcmp.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_riscv
 #elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP inline_memcmp_byte_per_byte
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE int inline_memcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP(
       reinterpret_cast<CPtr>(p1), reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCMP_H

libc/src/string/memory_utils/inline_memcpy.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
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCPY_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCPY_H
 
 #include "src/__support/macros/config.h"                   // LIBC_INLINE
 #include "src/__support/macros/properties/architectures.h" // LIBC_TARGET_ARCH_IS_
 #include "src/string/memory_utils/utils.h"                 // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_COPT_MEMCPY_USE_EMBEDDED_TINY)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_byte_per_byte
 #elif defined(LIBC_TARGET_ARCH_IS_X86)
-#include "src/string/memory_utils/x86_64/memcpy_implementations.h"
+#include "src/string/memory_utils/x86_64/inline_memcpy.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY                                    \
   inline_memcpy_x86_maybe_interpose_repmovsb
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
-#include "src/string/memory_utils/aarch64/memcpy_implementations.h"
+#include "src/string/memory_utils/aarch64/inline_memcpy.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-#include "src/string/memory_utils/riscv/memcpy_implementations.h"
+#include "src/string/memory_utils/riscv/inline_memcpy.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_riscv
 #elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY inline_memcpy_byte_per_byte
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE void inline_memcpy(void *__restrict dst, const void *__restrict src,
                                size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY(reinterpret_cast<Ptr>(dst),
                                       reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMCPY_H

libc/src/string/memory_utils/inline_memmem.h

 //===-- memmem 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_MEMMEM_IMPLEMENTATIONS_H
-#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMEM_IMPLEMENTATIONS_H
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMEM_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMEM_H
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-constexpr static void *
-memmem_implementation(const void *haystack, size_t haystack_len,
-                      const void *needle, size_t needle_len, Comp &&comp) {
+constexpr static void *inline_memmem(const void *haystack, size_t haystack_len,
+                                     const void *needle, size_t needle_len,
+                                     Comp &&comp) {
   // TODO: simple brute force implementation. This can be
   // improved upon using well known string matching algorithms.
   if (!needle_len)
     return const_cast<void *>(haystack);
 
   if (needle_len > haystack_len)
     return nullptr;
 
   const unsigned char *h = static_cast<const unsigned char *>(haystack);
   const unsigned char *n = static_cast<const unsigned char *>(needle);
   for (size_t i = 0; i <= (haystack_len - needle_len); ++i) {
     size_t j = 0;
     for (; j < needle_len && !comp(h[i + j], n[j]); ++j)
       ;
     if (j == needle_len)
       return const_cast<unsigned char *>(h + i);
   }
   return nullptr;
 }
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMEM_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMEM_H

libc/src/string/memory_utils/inline_memmove.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
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMOVE_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMOVE_H
 
 #include <stddef.h> // size_t, ptrdiff_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
-#include "src/string/memory_utils/x86_64/memmove_implementations.h"
+#include "src/string/memory_utils/x86_64/inline_memmove.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
-#include "src/string/memory_utils/aarch64/memmove_implementations.h"
+#include "src/string/memory_utils/aarch64/inline_memmove.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-#include "src/string/memory_utils/riscv/memmove_implementations.h"
+#include "src/string/memory_utils/riscv/inline_memmove.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_riscv
 #elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE inline_memmove_byte_per_byte
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE void inline_memmove(void *dst, const void *src, size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE(reinterpret_cast<Ptr>(dst),
                                        reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
-#endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */
+#endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMMOVE_H */

libc/src/string/memory_utils/inline_memset.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
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMSET_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMSET_H
 
 #include "src/__support/macros/config.h"                   // LIBC_INLINE
 #include "src/__support/macros/properties/architectures.h" // LIBC_TARGET_ARCH_IS_
 #include "src/string/memory_utils/utils.h"                 // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 #if defined(LIBC_TARGET_ARCH_IS_X86)
-#include "src/string/memory_utils/x86_64/memset_implementations.h"
+#include "src/string/memory_utils/x86_64/inline_memset.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_x86
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
-#include "src/string/memory_utils/aarch64/memset_implementations.h"
+#include "src/string/memory_utils/aarch64/inline_memset.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_aarch64
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
-#include "src/string/memory_utils/riscv/memset_implementations.h"
+#include "src/string/memory_utils/riscv/inline_memset.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_riscv
 #elif defined(LIBC_TARGET_ARCH_IS_ARM) || defined(LIBC_TARGET_ARCH_IS_GPU)
 #include "src/string/memory_utils/generic/byte_per_byte.h"
 #define LIBC_SRC_STRING_MEMORY_UTILS_MEMSET inline_memset_byte_per_byte
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
 LIBC_INLINE static void inline_memset(void *dst, uint8_t value, size_t count) {
   LIBC_SRC_STRING_MEMORY_UTILS_MEMSET(reinterpret_cast<Ptr>(dst), value, count);
 }
 
 } // namespace __llvm_libc
 
 #undef LIBC_SRC_STRING_MEMORY_UTILS_MEMSET
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_MEMSET_H

libc/src/string/memory_utils/inline_strcmp.h

 //===-- str{,case}cmp 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_STRCMP_IMPLEMENTATIONS_H
-#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRCMP_IMPLEMENTATIONS_H
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRCMP_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRCMP_H
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-LIBC_INLINE constexpr int
-strcmp_implementation(const char *left, const char *right, Comp &&comp) {
+LIBC_INLINE constexpr int inline_strcmp(const char *left, const char *right,
+                                        Comp &&comp) {
   // TODO: Look at benefits for comparing words at a time.
   for (; *left && !comp(*left, *right); ++left, ++right)
     ;
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 template <typename Comp>
-LIBC_INLINE constexpr int strncmp_implementation(const char *left,
-                                                 const char *right, size_t n,
-                                                 Comp &&comp) {
+LIBC_INLINE constexpr int inline_strncmp(const char *left, const char *right,
+                                         size_t n, Comp &&comp) {
   if (n == 0)
     return 0;
 
   // TODO: Look at benefits for comparing words at a time.
   for (; n > 1; --n, ++left, ++right) {
     char lc = *left;
     if (!comp(lc, '\0') || comp(lc, *right))
       break;
   }
   return comp(*reinterpret_cast<const unsigned char *>(left),
               *reinterpret_cast<const unsigned char *>(right));
 }
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRCMP_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRCMP_H

libc/src/string/memory_utils/inline_strstr.h

 //===-- str{,case}str 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_STRSTR_IMPLEMENTATIONS_H
-#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRSTR_IMPLEMENTATIONS_H
+#ifndef LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRSTR_H
+#define LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRSTR_H
 
-#include "src/string/memory_utils/memmem_implementations.h"
+#include "src/string/memory_utils/inline_memmem.h"
 #include "src/string/string_utils.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 template <typename Comp>
-LIBC_INLINE constexpr char *
-strstr_implementation(const char *haystack, const char *needle, Comp &&comp) {
-  void *result = memmem_implementation(
+LIBC_INLINE constexpr char *inline_strstr(const char *haystack,
+                                          const char *needle, Comp &&comp) {
+  void *result = inline_memmem(
       static_cast<const void *>(haystack), internal::string_length(haystack),
       static_cast<const void *>(needle), internal::string_length(needle), comp);
   return static_cast<char *>(result);
 }
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_STRSTR_IMPLEMENTATIONS_H
+#endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_INLINE_STRSTR_H

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

 //===-- Bcmp 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_BCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_BCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_BCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_BCMP_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/aligned_access.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE BcmpReturnType inline_bcmp_riscv(CPtr p1, CPtr p2,
                                                               size_t count) {
 #if defined(LIBC_TARGET_ARCH_IS_RISCV64)
   return inline_bcmp_aligned_access_64bit(p1, p2, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV32)
   return inline_bcmp_aligned_access_32bit(p1, p2, count);
 #else
 #error "Unimplemented"
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_BCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_BCMP_H

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

 //===-- Memcmp 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_MEMCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCMP_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/aligned_access.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE MemcmpReturnType
 inline_memcmp_riscv(CPtr p1, CPtr p2, size_t count) {
 #if defined(LIBC_TARGET_ARCH_IS_RISCV64)
   return inline_memcmp_aligned_access_64bit(p1, p2, count);
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV32)
   return inline_memcmp_aligned_access_32bit(p1, p2, count);
 #else
 #error "Unimplemented"
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCMP_H

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

 //===-- Memcpy 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_MEMCPY_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMCPY_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCPY_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCPY_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/aligned_access.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 [[maybe_unused]] LIBC_INLINE void
 inline_memcpy_riscv(Ptr __restrict dst, CPtr __restrict src, size_t count) {
 #if 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
 #error "Unimplemented"
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMCPY_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMCPY_H

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

 //===-- 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
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMMOVE_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMMOVE_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
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMMOVE_H

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

 //===-- Memset 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_MEMSET_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMSET_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMSET_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMSET_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/aligned_access.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
 LIBC_INLINE static void inline_memset_riscv(Ptr dst, uint8_t value,
                                             size_t count) {
 #if 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
 #error "Unimplemented"
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_MEMSET_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_RISCV_INLINE_MEMSET_H

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

 //===-- Bcmp implementation for x86_64 --------------------------*- 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_X86_64_BCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_BCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_BCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_BCMP_H
 
 #include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
#elif defined(__SSE4_1__)
   return inline_bcmp_x86_sse41_gt16(p1, p2, count);
 #else
   return inline_bcmp_generic_gt16(p1, p2, count);
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_BCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_BCMP_H

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

 //===-- Memcmp implementation for x86_64 ------------------------*- 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_X86_64_MEMCMP_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCMP_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H
 
 #include "src/__support/macros/config.h"       // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h" // MemcmpReturnType
 
 namespace __llvm_libc {
#elif defined(__SSE4_1__)
   return inline_memcmp_x86_sse41_gt16(p1, p2, count);
 #else
   return inline_memcmp_generic_gt16(p1, p2, count);
 #endif
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCMP_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCMP_H

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

 //===-- Memcpy implementation for x86_64 ------------------------*- 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_X86_64_MEMCPY_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCPY_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCPY_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCPY_H
 
 #include "src/__support/macros/attributes.h"   // LIBC_INLINE_VAR
 #include "src/__support/macros/config.h"       // LIBC_INLINE
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
 #include "src/string/memory_utils/op_builtin.h"
 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h"
 
if (LIBC_UNLIKELY(count >= x86::kRepMovsbThreshold))
       return x86::Memcpy::repmovsb(dst, src, count);
     else
       return inline_memcpy_x86(dst, src, count);
   }
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMCPY_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMCPY_H

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

 //===-- Memmove implementation for x86_64 -----------------------*- 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_X86_64_MEMMOVE_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMMOVE_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMMOVE_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMMOVE_H
 
 #include "src/__support/macros/config.h" // LIBC_INLINE
 #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
#endif
   } else {
     generic::Memmove<uint256_t>::align_backward<Arg::Src>(dst, src, count);
     return generic::Memmove<uint512_t>::loop_and_tail_backward(dst, src, count);
   }
 }
 
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMMOVE_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMMOVE_H

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

 //===-- Memset implementation for x86_64 ------------------------*- 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_X86_64_MEMSET_IMPLEMENTATIONS_H
-#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMSET_IMPLEMENTATIONS_H
+#ifndef LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMSET_H
+#define LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMSET_H
 
 #include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/string/memory_utils/op_generic.h"
 #include "src/string/memory_utils/op_x86.h"
 #include "src/string/memory_utils/utils.h" // Ptr, CPtr
 
 #include <stddef.h> // size_t
 
if (count <= 128)
     return generic::Memset<uint512_t>::head_tail(dst, value, count);
   // Aligned loop
   generic::Memset<uint256_t>::block(dst, value);
   align_to_next_boundary<32>(dst, count);
   return generic::Memset<uint256_t>::loop_and_tail(dst, value, count);
 }
 } // namespace __llvm_libc
 
-#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_MEMSET_IMPLEMENTATIONS_H
+#endif // LIBC_SRC_STRING_MEMORY_UTILS_X86_64_INLINE_MEMSET_H

libc/src/string/mempcpy.cpp

 //===-- Implementation of mempcpy ----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/mempcpy.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include "src/__support/common.h"
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, mempcpy,
                    (void *__restrict dst, const void *__restrict src,
                     size_t count)) {
   inline_memcpy(dst, src, count);
   return reinterpret_cast<char *>(dst) + count;
 }
 
 } // namespace __llvm_libc

libc/src/string/memset.cpp

 //===-- Implementation of memset ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/memset.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memset_implementations.h"
+#include "src/string/memory_utils/inline_memset.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, memset, (void *dst, int value, size_t count)) {
   inline_memset(dst, static_cast<uint8_t>(value), count);
   return dst;
 }
 
 } // namespace __llvm_libc

libc/src/string/stpncpy.cpp

 //===-- Implementation of stpncpy -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/stpncpy.h"
-#include "src/string/memory_utils/bzero_implementations.h"
+#include "src/string/memory_utils/inline_bzero.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, stpncpy,
                    (char *__restrict dest, const char *__restrict src,
                     size_t n)) {

libc/src/string/strcasecmp.cpp

 //===-- Implementation of strcasecmp --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcasecmp.h"
 
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
-#include "src/string/memory_utils/strcmp_implementations.h"
+#include "src/string/memory_utils/inline_strcmp.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, strcasecmp, (const char *left, const char *right)) {
   auto case_cmp = [](char a, char b) {
     return __llvm_libc::internal::tolower(a) -
            __llvm_libc::internal::tolower(b);
   };
-  return strcmp_implementation(left, right, case_cmp);
+  return inline_strcmp(left, right, case_cmp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strcasestr.cpp

 //===-- Implementation of strcasestr --------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcasestr.h"
 
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
-#include "src/string/memory_utils/strstr_implementations.h"
+#include "src/string/memory_utils/inline_strstr.h"
 
 namespace __llvm_libc {
 
 // TODO: This is a simple brute force implementation. This can be
 // improved upon using well known string matching algorithms.
 LLVM_LIBC_FUNCTION(char *, strcasestr,
                    (const char *haystack, const char *needle)) {
   auto case_cmp = [](char a, char b) {
     return __llvm_libc::internal::tolower(a) -
            __llvm_libc::internal::tolower(b);
   };
-  return strstr_implementation(haystack, needle, case_cmp);
+  return inline_strstr(haystack, needle, case_cmp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strcmp.cpp

 //===-- Implementation of strcmp ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcmp.h"
 
 #include "src/__support/common.h"
-#include "src/string/memory_utils/strcmp_implementations.h"
+#include "src/string/memory_utils/inline_strcmp.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, strcmp, (const char *left, const char *right)) {
   auto comp = [](char l, char r) -> int { return l - r; };
-  return strcmp_implementation(left, right, comp);
+  return inline_strcmp(left, right, comp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strcpy.cpp

 //===-- Implementation of strcpy ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strcpy.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strcpy,
                    (char *__restrict dest, const char *__restrict src)) {
   size_t size = internal::string_length(src) + 1;
   inline_memcpy(dest, src, size);
   return dest;
 }
 
 } // namespace __llvm_libc

libc/src/string/strdup.cpp

 //===-- Implementation of strdup ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strdup.h"
 #include "src/errno/libc_errno.h"
 #include "src/string/allocating_string_utils.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include "src/__support/common.h"
 
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strdup, (const char *src)) {

libc/src/string/string_utils.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBC_SRC_STRING_STRING_UTILS_H
 #define LIBC_SRC_STRING_STRING_UTILS_H
 
 #include "src/__support/CPP/bitset.h"
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
-#include "src/string/memory_utils/bzero_implementations.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_bzero.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 #include <stddef.h> // For size_t
 
 namespace __llvm_libc {
 namespace internal {
 
 template <typename Word> constexpr Word repeat_byte(Word byte) {
   constexpr size_t BITS_IN_BYTE = 8;
   constexpr size_t BYTE_MASK = 0xff;

libc/src/string/strncasecmp.cpp

 //===-- Implementation of strncasecmp -------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strncasecmp.h"
 
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
-#include "src/string/memory_utils/strcmp_implementations.h"
+#include "src/string/memory_utils/inline_strcmp.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, strncasecmp,
                    (const char *left, const char *right, size_t n)) {
   auto case_cmp = [](char a, char b) {
     return __llvm_libc::internal::tolower(a) -
            __llvm_libc::internal::tolower(b);
   };
-  return strncmp_implementation(left, right, n, case_cmp);
+  return inline_strncmp(left, right, n, case_cmp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strncmp.cpp

 //===-- Implementation of strncmp -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strncmp.h"
 
 #include "src/__support/common.h"
-#include "src/string/memory_utils/strcmp_implementations.h"
+#include "src/string/memory_utils/inline_strcmp.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, strncmp,
                    (const char *left, const char *right, size_t n)) {
   auto comp = [](char l, char r) -> int { return l - r; };
-  return strncmp_implementation(left, right, n, comp);
+  return inline_strncmp(left, right, n, comp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strndup.cpp

 //===-- Implementation of strndup -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strndup.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/common.h"
 
 #include <stddef.h>
 
 namespace __llvm_libc {

libc/src/string/strstr.cpp

 //===-- Implementation of strstr ------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strstr.h"
 
 #include "src/__support/common.h"
-#include "src/string/memory_utils/strstr_implementations.h"
+#include "src/string/memory_utils/inline_strstr.h"
 
 namespace __llvm_libc {
 
 // TODO: This is a simple brute force implementation. This can be
 // improved upon using well known string matching algorithms.
 LLVM_LIBC_FUNCTION(char *, strstr, (const char *haystack, const char *needle)) {
   auto comp = [](char l, char r) -> int { return l - r; };
-  return strstr_implementation(haystack, needle, comp);
+  return inline_strstr(haystack, needle, comp);
 }
 
 } // namespace __llvm_libc

libc/src/string/strxfrm.cpp

 //===-- Implementation of strxfrm -----------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/string/strxfrm.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // TODO: Add support for locales.
 LLVM_LIBC_FUNCTION(size_t, strxfrm,

libc/startup/linux/aarch64/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
     libc.src.stdlib.exit
     libc.src.stdlib.atexit
-    libc.src.string.memory_utils.memcpy_implementation
+    libc.src.string.memory_utils.inline_memcpy
     libc.src.unistd.environ
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
 )

libc/startup/linux/aarch64/start.cpp

 //===-- Implementation of crt for aarch64 ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "config/linux/app.h"
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/threads/thread.h"
 #include "src/stdlib/atexit.h"
 #include "src/stdlib/exit.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include <arm_acle.h>
 
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>

libc/startup/linux/riscv64/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
     libc.src.stdlib.exit
     libc.src.stdlib.atexit
-    libc.src.string.memory_utils.memcpy_implementation
+    libc.src.string.memory_utils.inline_memcpy
     libc.src.unistd.environ
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
 )

libc/startup/linux/riscv64/start.cpp

 //===-- Implementation of crt for riscv64 ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "config/linux/app.h"
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/threads/thread.h"
 #include "src/stdlib/atexit.h"
 #include "src/stdlib/exit.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 

libc/startup/linux/x86_64/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.config.linux.app_h
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.include.unistd
     libc.src.__support.threads.thread
     libc.src.__support.OSUtil.osutil
     libc.src.stdlib.exit
     libc.src.stdlib.atexit
-    libc.src.string.memory_utils.memcpy_implementation
+    libc.src.string.memory_utils.inline_memcpy
     libc.src.unistd.environ
   COMPILE_OPTIONS
     -fno-omit-frame-pointer
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
 )

libc/startup/linux/x86_64/start.cpp

 //===-- Implementation of crt for x86_64 ----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "config/linux/app.h"
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/threads/thread.h"
 #include "src/stdlib/atexit.h"
 #include "src/stdlib/exit.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 
 #include <asm/prctl.h>
 #include <linux/auxvec.h>
 #include <linux/elf.h>
 #include <stdint.h>
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>

libc/test/integration/startup/gpu/rpc_stream_test.cpp

 //===-- Loader test to check the RPC streaming interface with the loader --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/GPU/utils.h"
 #include "src/__support/RPC/rpc_client.h"
 #include "src/__support/integer_to_string.h"
-#include "src/string/memory_utils/memcmp_implementations.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/string/memory_utils/inline_memcmp.h"
+#include "src/string/memory_utils/inline_memcpy.h"
 #include "src/string/string_utils.h"
 #include "test/IntegrationTest/test.h"
 
 extern "C" void *malloc(uint64_t);
 extern "C" void free(void *);
 
 using namespace __llvm_libc;
 

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

hdrs = [
         "src/string/memory_utils/op_builtin.h",
         "src/string/memory_utils/op_generic.h",
         "src/string/memory_utils/op_riscv.h",
         "src/string/memory_utils/op_x86.h",
         "src/string/memory_utils/utils.h",
     ],
     defines = MEMORY_COPTS,
     textual_hdrs = [
-        "src/string/memory_utils/aarch64/bcmp_implementations.h",
-        "src/string/memory_utils/aarch64/memcmp_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/bcmp_implementations.h",
-        "src/string/memory_utils/bzero_implementations.h",
+        "src/string/memory_utils/aarch64/inline_bcmp.h",
+        "src/string/memory_utils/aarch64/inline_memcmp.h",
+        "src/string/memory_utils/aarch64/inline_memcpy.h",
+        "src/string/memory_utils/aarch64/inline_memmove.h",
+        "src/string/memory_utils/aarch64/inline_memset.h",
         "src/string/memory_utils/generic/aligned_access.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/riscv/bcmp_implementations.h",
-        "src/string/memory_utils/riscv/memcmp_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/strcmp_implementations.h",
-        "src/string/memory_utils/strstr_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/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/inline_bcmp.h",
+        "src/string/memory_utils/inline_bzero.h",
+        "src/string/memory_utils/inline_memcmp.h",
+        "src/string/memory_utils/inline_memcpy.h",
+        "src/string/memory_utils/inline_memmem.h",
+        "src/string/memory_utils/inline_memmove.h",
+        "src/string/memory_utils/inline_memset.h",
+        "src/string/memory_utils/inline_strcmp.h",
+        "src/string/memory_utils/inline_strstr.h",
+        "src/string/memory_utils/riscv/inline_bcmp.h",
+        "src/string/memory_utils/riscv/inline_memcmp.h",
+        "src/string/memory_utils/riscv/inline_memcpy.h",
+        "src/string/memory_utils/riscv/inline_memmove.h",
+        "src/string/memory_utils/riscv/inline_memset.h",
+        "src/string/memory_utils/x86_64/inline_bcmp.h",
+        "src/string/memory_utils/x86_64/inline_memcmp.h",
+        "src/string/memory_utils/x86_64/inline_memcpy.h",
+        "src/string/memory_utils/x86_64/inline_memmove.h",
+        "src/string/memory_utils/x86_64/inline_memset.h",
     ],
     deps = [
         ":__support_common",
         ":__support_cpp_array",
         ":__support_cpp_bit",
         ":__support_cpp_cstddef",
         ":__support_cpp_type_traits",
         ":__support_macros_attributes",