[libc] Add a trivial implementation for bcmp

[sivachandra]

LGTM. We need to add an entry for bcmp here to keep the integration tests running: https://github.com/llvm/llvm-project/blob/main/libc/spec/llvm_libc_ext.td

libc/src/string/bcmp.cpp

19

Nit: Since the body of the for loop is more than one line, we should add braces.

[gchatelet]

• Address comments and rebase

[gchatelet]

• Use ConstVoidPtr instead of VoidPtr

libc/benchmarks/CMakeLists.txt

foreach(fq_config_name IN LISTS fq_implementations)
     endif()
   endforeach()
 endfunction()
 
 add_libc_multi_impl_benchmark(memcpy)
 add_libc_multi_impl_benchmark(memset)
 add_libc_multi_impl_benchmark(bzero)
 add_libc_multi_impl_benchmark(memcmp)
+add_libc_multi_impl_benchmark(bcmp)
 
 #==============================================================================
 # Google Benchmarking tool
 #==============================================================================
 
 # This target uses the Google Benchmark facility to report throughput for llvm
 # libc memory functions compiled for the host machine. This is useful to
 # continuously monitor the performance of the memory functions.
 add_executable(libc.benchmarks.memory_functions.opt_host
   EXCLUDE_FROM_ALL
   LibcMemoryGoogleBenchmarkMain.cpp
 )
 
 target_link_libraries(libc.benchmarks.memory_functions.opt_host
   PRIVATE
   libc-memory-benchmark
   libc.src.string.memcmp_opt_host
+  libc.src.string.bcmp_opt_host
   libc.src.string.memcpy_opt_host
   libc.src.string.memset_opt_host
   libc.src.string.bzero_opt_host
   benchmark_main
 )

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

 #include <unistd.h>
 
 namespace __llvm_libc {
 
 extern void *memcpy(void *__restrict, const void *__restrict, size_t);
 extern void *memset(void *, int, size_t);
 extern void bzero(void *, size_t);
 extern int memcmp(const void *, const void *, size_t);
+extern int bcmp(const void *, const void *, size_t);
 
 } // namespace __llvm_libc
 
 namespace llvm {
 namespace libc_benchmarks {
 
 static cl::opt<std::string>
     StudyName("study-name", cl::desc("The name for this study"), cl::Required);

 #define LIBC_BENCHMARK_FUNCTION LIBC_BENCHMARK_FUNCTION_MEMSET
 using BenchmarkSetup = SetSetup;
 #elif defined(LIBC_BENCHMARK_FUNCTION_BZERO)
 #define LIBC_BENCHMARK_FUNCTION LIBC_BENCHMARK_FUNCTION_BZERO
 using BenchmarkSetup = SetSetup;
 #elif defined(LIBC_BENCHMARK_FUNCTION_MEMCMP)
 #define LIBC_BENCHMARK_FUNCTION LIBC_BENCHMARK_FUNCTION_MEMCMP
 using BenchmarkSetup = ComparisonSetup;
+#elif defined(LIBC_BENCHMARK_FUNCTION_BCMP)
+#define LIBC_BENCHMARK_FUNCTION LIBC_BENCHMARK_FUNCTION_BCMP
+using BenchmarkSetup = ComparisonSetup;
 #else
 #error "Missing LIBC_BENCHMARK_FUNCTION_XXX definition"
 #endif
 
 struct MemfunctionBenchmarkBase : public BenchmarkSetup {
   MemfunctionBenchmarkBase() : ReportProgress(isatty(fileno(stdout))) {}
   virtual ~MemfunctionBenchmarkBase() {}
 

libc/benchmarks/LibcMemoryGoogleBenchmarkMain.cpp

 using llvm::libc_benchmarks::SetSetup;
 
 namespace __llvm_libc {
 
 extern void *memcpy(void *__restrict, const void *__restrict, size_t);
 extern void *memset(void *, int, size_t);
 extern void bzero(void *, size_t);
 extern int memcmp(const void *, const void *, size_t);
+extern int bcmp(const void *, const void *, size_t);
 
 } // namespace __llvm_libc
 
 // List of implementations to test.
 static constexpr MemcpyConfiguration kMemcpyConfigurations[] = {
     {__llvm_libc::memcpy, "__llvm_libc::memcpy"}};
 
 static constexpr MemcmpConfiguration kMemcmpConfigurations[] = {
     {__llvm_libc::memcmp, "__llvm_libc::memcmp"}};
 
+static constexpr MemcmpConfiguration kBcmpConfigurations[] = {
+    {__llvm_libc::bcmp, "__llvm_libc::bcmp"}};
+
 static constexpr MemsetConfiguration kMemsetConfigurations[] = {
     {__llvm_libc::memset, "__llvm_libc::memset"}};
 
 static constexpr BzeroConfiguration kBzeroConfigurations[] = {
     {__llvm_libc::bzero, "__llvm_libc::bzero"}};
 
 // Alignment to use for when accessing the buffers.
 static constexpr Align kBenchmarkAlignment = Align::Constant<1>();
for (int64_t DistIndex = 0; DistIndex < DistributionSize; ++DistIndex)     \
       for (int64_t ConfIndex = 0; ConfIndex < ConfigurationSize; ++ConfIndex)  \
         benchmark->Args({DistIndex, ConfIndex});                               \
   })
 
 BENCHMARK_MEMORY_FUNCTION(BM_Memcpy, CopySetup, MemcpyConfiguration,
                           llvm::makeArrayRef(kMemcpyConfigurations));
 BENCHMARK_MEMORY_FUNCTION(BM_Memcmp, ComparisonSetup, MemcmpConfiguration,
                           llvm::makeArrayRef(kMemcmpConfigurations));
+BENCHMARK_MEMORY_FUNCTION(BM_Bcmp, ComparisonSetup, MemcmpConfiguration,
+                          llvm::makeArrayRef(kBcmpConfigurations));
 BENCHMARK_MEMORY_FUNCTION(BM_Memset, SetSetup, MemsetConfiguration,
                           llvm::makeArrayRef(kMemsetConfigurations));
 BENCHMARK_MEMORY_FUNCTION(BM_Bzero, SetSetup, BzeroConfiguration,
                           llvm::makeArrayRef(kBzeroConfigurations));

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.ctype.toascii
     libc.src.ctype.tolower
     libc.src.ctype.toupper
     
     # errno.h entrypoints
     libc.src.errno.__errno_location
 
     # string.h entrypoints
+    libc.src.string.bcmp
     libc.src.string.bzero
     libc.src.string.memchr
     libc.src.string.memcmp
     libc.src.string.memcpy
     libc.src.string.memmove
     libc.src.string.memset
     libc.src.string.memrchr
     libc.src.string.strcat

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.ctype.toascii
     libc.src.ctype.tolower
     libc.src.ctype.toupper
 
     # errno.h entrypoints
     libc.src.errno.__errno_location
 
     # string.h entrypoints
+    libc.src.string.bcmp
     libc.src.string.bzero
     libc.src.string.memchr
     libc.src.string.memcmp
     libc.src.string.memcpy
     libc.src.string.memmove
     libc.src.string.memrchr
     libc.src.string.memset
     libc.src.string.strcat

libc/spec/llvm_libc_ext.td

 def LLVMLibcExt : StandardSpec<"llvm_libc_ext"> {
   HeaderSpec String = HeaderSpec<
       "string.h",
       [], // Macros
       [], // Types
       [], // Enumerations
       [
           FunctionSpec<
               "bzero",
               RetValSpec<VoidType>,
-              [ArgSpec<VoidPtr>,
-               ArgSpec<SizeTType>]
+              [ArgSpec<VoidPtr>, ArgSpec<SizeTType>]
+          >,
+      ]
+  >;
+
+  HeaderSpec String = HeaderSpec<
+      "string.h",
+      [], // Macros
+      [], // Types
+      [], // Enumerations
+      [
+          FunctionSpec<
+              "bcmp",
+              RetValSpec<IntType>,
+              [ArgSpec<ConstVoidPtr>, ArgSpec<ConstVoidPtr>, ArgSpec<SizeTType>]
           >,
       ]
   >;
 
   HeaderSpec Assert = HeaderSpec<
       "assert.h",
       [], // Macros
       [], // Types
       [], // Enumerations
       [
           FunctionSpec<
               "__assert_fail",
               RetValSpec<NoReturn>,
-              [ArgSpec<ConstCharPtr>,
-               ArgSpec<ConstCharPtr>,
-               ArgSpec<UnsignedType>,
-               ArgSpec<ConstCharPtr>,]
+              [ArgSpec<ConstCharPtr>, ArgSpec<ConstCharPtr>, ArgSpec<UnsignedType>, ArgSpec<ConstCharPtr>]
 
           >,
       ]
   >;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [], // Macros

libc/src/string/CMakeLists.txt

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})
 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()
+
+# ------------------------------------------------------------------------------
+# bcmp
+# ------------------------------------------------------------------------------
+
+function(add_bcmp bcmp_name)
+  add_implementation(bcmp ${bcmp_name}
+    SRCS ${LIBC_BCMP_SRC}
+    HDRS ${LIBC_SOURCE_DIR}/src/string/bcmp.h
+    DEPENDS
+      .memory_utils.memory_utils
+      libc.include.string
+    COMPILE_OPTIONS
+      -fno-builtin-memcmp
+      -fno-builtin-bcmp
+    ${ARGN}
+  )
+endfunction()
+
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  set(LIBC_BCMP_SRC ${LIBC_SOURCE_DIR}/src/string/bcmp.cpp)
+  add_bcmp(bcmp_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
+  add_bcmp(bcmp_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
+  add_bcmp(bcmp_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
+  add_bcmp(bcmp_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
+  add_bcmp(bcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_bcmp(bcmp)
+else()
+  set(LIBC_BCMP_SRC ${LIBC_SOURCE_DIR}/src/string/bcmp.cpp)
+  add_bcmp(bcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_bcmp(bcmp)
+endif()

libc/src/string/bcmp.h

+//===-- Implementation header for bzero -------------------------*- 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_BCMP_H
+#define LLVM_LIBC_SRC_STRING_BCMP_H
+
+#include <stddef.h> // size_t
+
+namespace __llvm_libc {
+
+int bcmp(const void *lhs, const void *rhs, size_t count);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_STRING_BCMP_H

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"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, bcmp,
+                   (const void *lhs, const void *rhs, size_t count)) {
+  const unsigned char *_lhs = reinterpret_cast<const unsigned char *>(lhs);
+  const unsigned char *_rhs = reinterpret_cast<const unsigned char *>(rhs);
+  for (size_t i = 0; i < count; ++i) {
+    if (_lhs[i] != _rhs[i]) {
+      return 1;
+    }
+  }
+  // count is 0 or _lhs and _rhs are the same.
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/test/src/string/CMakeLists.txt

foreach(fq_config_name IN LISTS fq_implementations)
     endif()
   endforeach()
 endfunction()
 
 add_libc_multi_impl_test(memcpy SRCS memcpy_test.cpp)
 add_libc_multi_impl_test(memset SRCS memset_test.cpp)
 add_libc_multi_impl_test(bzero SRCS bzero_test.cpp)
 add_libc_multi_impl_test(memcmp SRCS memcmp_test.cpp)
+add_libc_multi_impl_test(bcmp SRCS bcmp_test.cpp)
 add_libc_multi_impl_test(memmove SRCS memmove_test.cpp)

libc/test/src/string/bcmp_test.cpp

+//===-- Unittests 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/string/bcmp.h"
+#include "utils/UnitTest/Test.h"
+
+TEST(LlvmLibcBcmpTest, CmpZeroByte) {
+  const char *lhs = "ab";
+  const char *rhs = "bc";
+  EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, 0), 0);
+}
+
+TEST(LlvmLibcBcmpTest, LhsRhsAreTheSame) {
+  const char *lhs = "ab";
+  const char *rhs = "ab";
+  EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, 2), 0);
+}
+
+TEST(LlvmLibcBcmpTest, LhsBeforeRhsLexically) {
+  const char *lhs = "ab";
+  const char *rhs = "ac";
+  EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, 2), 1);
+}
+
+TEST(LlvmLibcBcmpTest, LhsAfterRhsLexically) {
+  const char *lhs = "ac";
+  const char *rhs = "ab";
+  EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, 2), 1);
+}
+
+TEST(LlvmLibcBcmpTest, Sweep) {
+  static constexpr size_t kMaxSize = 1024;
+  char lhs[kMaxSize];
+  char rhs[kMaxSize];
+
+  const auto reset = [](char *const ptr) {
+    for (size_t i = 0; i < kMaxSize; ++i)
+      ptr[i] = 'a';
+  };
+
+  reset(lhs);
+  reset(rhs);
+  for (size_t i = 0; i < kMaxSize; ++i)
+    EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, i), 0);
+
+  reset(lhs);
+  reset(rhs);
+  for (size_t i = 0; i < kMaxSize; ++i) {
+    rhs[i] = 'b';
+    EXPECT_EQ(__llvm_libc::bcmp(lhs, rhs, kMaxSize), 1);
+    rhs[i] = 'a';
+  }
+}