[libc][NFC] Allow memcmp to be inlined

[gchatelet]

Summary

Similar to D113097 although not strictly necessary for now. It helps
keeping the same structure for all memory functions.

[gchatelet]

• Fix commit message to use memcmp instead of memcpy

[michaelrj]

LGTM

[michaelrj]

LGTM with the same comment about header guards as the previous change.

[gchatelet]

• Rename filename
• Rename function
• Add header guard

[gchatelet]

• rebase

libc/src/string/CMakeLists.txt

 endif()
 
 # ------------------------------------------------------------------------------
 # memcmp
 # ------------------------------------------------------------------------------
 
 function(add_memcmp memcmp_name)
   add_implementation(memcmp ${memcmp_name}
-    SRCS ${LIBC_MEMCMP_SRC}
+    SRCS ${LIBC_SOURCE_DIR}/src/string/memcmp.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memcmp.h
     DEPENDS
       .memory_utils.memory_utils
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memcmp
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
-  set(LIBC_MEMCMP_SRC ${LIBC_SOURCE_DIR}/src/string/memcmp.cpp)
   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)
   add_memcmp(memcmp_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
   add_memcmp(memcmp_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
   add_memcmp(memcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memcmp(memcmp)
 elseif(${LIBC_TARGET_ARCHITECTURE_IS_AARCH64})
-  set(LIBC_MEMCMP_SRC ${LIBC_SOURCE_DIR}/src/string/aarch64/memcmp.cpp)
-  add_memcmp(memcmp)
   add_memcmp(memcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_memcmp(memcmp)
 else()
-  set(LIBC_MEMCMP_SRC ${LIBC_SOURCE_DIR}/src/string/memcmp.cpp)
   add_memcmp(memcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_memcmp(memcmp)
 endif()
 
 # ------------------------------------------------------------------------------
 # memcpy
 # ------------------------------------------------------------------------------
 

libc/src/string/aarch64/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/__support/common.h"
-#include "src/string/memory_utils/elements.h"
-#include <stddef.h> // size_t
-
-namespace __llvm_libc {
-
-static int memcmp_aarch64(const char *lhs, const char *rhs, size_t count) {
-  // Use aarch64 strategies (_1, _2, _3 ...)
-  using namespace __llvm_libc::aarch64;
-
-  if (count == 0) // [0, 0]
-    return 0;
-  if (count == 1) // [1, 1]
-    return ThreeWayCompare<_1>(lhs, rhs);
-  if (count == 2) // [2, 2]
-    return ThreeWayCompare<_2>(lhs, rhs);
-  if (count == 3) // [3, 3]
-    return ThreeWayCompare<_3>(lhs, rhs);
-  if (count < 8) // [4, 7]
-    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
-  if (count < 16) // [8, 15]
-    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
-  if (unlikely(count >= 128)) // [128, ∞]
-    return ThreeWayCompare<Align<_16>::Then<Loop<_32>>>(lhs, rhs, count);
-  if (!Equals<_16>(lhs, rhs)) // [16, 16]
-    return ThreeWayCompare<_16>(lhs, rhs);
-  if (count < 32) // [17, 31]
-    return ThreeWayCompare<Tail<_16>>(lhs, rhs, count);
-  if (!Equals<Skip<16>::Then<_16>>(lhs, rhs)) // [32, 32]
-    return ThreeWayCompare<Skip<16>::Then<_16>>(lhs, rhs);
-  if (count < 64) // [33, 63]
-    return ThreeWayCompare<Tail<_32>>(lhs, rhs, count);
-  // [64, 127]
-  return ThreeWayCompare<Skip<32>::Then<Loop<_16>>>(lhs, rhs, count);
-}
-
-LLVM_LIBC_FUNCTION(int, memcmp,
-                   (const void *lhs, const void *rhs, size_t count)) {
-  return memcmp_aarch64(reinterpret_cast<const char *>(lhs),
-                        reinterpret_cast<const char *>(rhs), 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/__support/architectures.h"
-#include "src/__support/common.h"
-#include "src/string/memory_utils/elements.h"
+#include "src/string/memory_utils/memcmp_implementations.inl"
 
 #include <stddef.h> // size_t
 
 namespace __llvm_libc {
 
-static int memcmp_impl(const char *lhs, const char *rhs, size_t count) {
-#if defined(LLVM_LIBC_ARCH_X86)
-  using namespace ::__llvm_libc::x86;
-#else
-  using namespace ::__llvm_libc::scalar;
-#endif
-
-  if (count == 0)
-    return 0;
-  if (count == 1)
-    return ThreeWayCompare<_1>(lhs, rhs);
-  if (count == 2)
-    return ThreeWayCompare<_2>(lhs, rhs);
-  if (count == 3)
-    return ThreeWayCompare<_3>(lhs, rhs);
-  if (count <= 8)
-    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
-  if (count <= 16)
-    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
-  if (count <= 32)
-    return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, count);
-  if (count <= 64)
-    return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, count);
-  if (count <= 128)
-    return ThreeWayCompare<HeadTail<_64>>(lhs, rhs, count);
-  return ThreeWayCompare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
-}
-
 LLVM_LIBC_FUNCTION(int, memcmp,
                    (const void *lhs, const void *rhs, size_t count)) {
-  return memcmp_impl(static_cast<const char *>(lhs),
+  return inlined_memcmp(static_cast<const char *>(lhs),
                         static_cast<const char *>(rhs), count);
 }
 
 } // namespace __llvm_libc

libc/src/string/memory_utils/memcmp_implementations.inl

+//===-- 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/__support/architectures.h"
+#include "src/__support/common.h"
+#include "src/string/memory_utils/elements.h"
+
+#include <stddef.h> // size_t
+
+namespace __llvm_libc {
+
+static inline int inlined_memcmp(const char *lhs, const char *rhs,
+                                 size_t count) {
+#if defined(LLVM_LIBC_ARCH_X86)
+  /////////////////////////////////////////////////////////////////////////////
+  // LLVM_LIBC_ARCH_X86
+  /////////////////////////////////////////////////////////////////////////////
+  using namespace __llvm_libc::x86;
+  if (count == 0)
+    return 0;
+  if (count == 1)
+    return ThreeWayCompare<_1>(lhs, rhs);
+  if (count == 2)
+    return ThreeWayCompare<_2>(lhs, rhs);
+  if (count == 3)
+    return ThreeWayCompare<_3>(lhs, rhs);
+  if (count <= 8)
+    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+  if (count <= 16)
+    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+  if (count <= 32)
+    return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, count);
+  if (count <= 64)
+    return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, count);
+  if (count <= 128)
+    return ThreeWayCompare<HeadTail<_64>>(lhs, rhs, count);
+  return ThreeWayCompare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
+#elif defined(LLVM_LIBC_ARCH_AARCH64)
+  /////////////////////////////////////////////////////////////////////////////
+  // LLVM_LIBC_ARCH_AARCH64
+  /////////////////////////////////////////////////////////////////////////////
+  using namespace ::__llvm_libc::aarch64;
+  if (count == 0) // [0, 0]
+    return 0;
+  if (count == 1) // [1, 1]
+    return ThreeWayCompare<_1>(lhs, rhs);
+  if (count == 2) // [2, 2]
+    return ThreeWayCompare<_2>(lhs, rhs);
+  if (count == 3) // [3, 3]
+    return ThreeWayCompare<_3>(lhs, rhs);
+  if (count < 8) // [4, 7]
+    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+  if (count < 16) // [8, 15]
+    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+  if (unlikely(count >= 128)) // [128, ∞]
+    return ThreeWayCompare<Align<_16>::Then<Loop<_32>>>(lhs, rhs, count);
+  if (!Equals<_16>(lhs, rhs)) // [16, 16]
+    return ThreeWayCompare<_16>(lhs, rhs);
+  if (count < 32) // [17, 31]
+    return ThreeWayCompare<Tail<_16>>(lhs, rhs, count);
+  if (!Equals<Skip<16>::Then<_16>>(lhs, rhs)) // [32, 32]
+    return ThreeWayCompare<Skip<16>::Then<_16>>(lhs, rhs);
+  if (count < 64) // [33, 63]
+    return ThreeWayCompare<Tail<_32>>(lhs, rhs, count);
+  // [64, 127]
+  return ThreeWayCompare<Skip<32>::Then<Loop<_16>>>(lhs, rhs, count);
+#else
+  /////////////////////////////////////////////////////////////////////////////
+  // Default
+  /////////////////////////////////////////////////////////////////////////////
+  using namespace ::__llvm_libc::scalar;
+
+  if (count == 0)
+    return 0;
+  if (count == 1)
+    return ThreeWayCompare<_1>(lhs, rhs);
+  if (count == 2)
+    return ThreeWayCompare<_2>(lhs, rhs);
+  if (count == 3)
+    return ThreeWayCompare<_3>(lhs, rhs);
+  if (count <= 8)
+    return ThreeWayCompare<HeadTail<_4>>(lhs, rhs, count);
+  if (count <= 16)
+    return ThreeWayCompare<HeadTail<_8>>(lhs, rhs, count);
+  if (count <= 32)
+    return ThreeWayCompare<HeadTail<_16>>(lhs, rhs, count);
+  if (count <= 64)
+    return ThreeWayCompare<HeadTail<_32>>(lhs, rhs, count);
+  if (count <= 128)
+    return ThreeWayCompare<HeadTail<_64>>(lhs, rhs, count);
+  return ThreeWayCompare<Align<_32>::Then<Loop<_32>>>(lhs, rhs, count);
+#endif
+}
+
+} // namespace __llvm_libc