[libc] Make string entrypoints mutualy exclusive.

[gchatelet]

Summary

For example, strcpy does not pull memcpy now.

[gchatelet]

libc/src/string/mempcpy.cpp

20–21

nit: Not sure this is part of the spec. It's probably fine to let it SIGSEGV.

24

nit: Not strictly necessary since every pointer casts to void*

libc/src/string/strcpy.cpp

30

that would be dest

[sivachandra]

Address comments.

[sivachandra]

libc/src/string/mempcpy.cpp

24

I tried to retain the original as much as possible. But, I changed according to your suggestion.

libc/src/string/strcpy.cpp

30

Thanks for catching this. But, I completely removed the sanitizer part now as we don't use memcpy anymore.

[gchatelet]

The code is clearer now with much less reinterpret_casts :)

[gchatelet]

@sivachandra I'll push this patch if you don't mind.

[gchatelet]

• rebase

libc/src/string/CMakeLists.txt

 
 add_entrypoint_object(
   mempcpy
   SRCS
     mempcpy.cpp
   HDRS
     mempcpy.h
   DEPENDS
-    libc.src.string.memcpy
+    .memory_utils.memcpy_implementation
 )
 
 add_entrypoint_object(
   memchr
   SRCS
     memchr.cpp
   HDRS
     memchr.h
   DEPENDS
     .string_utils
 )
 
 add_entrypoint_object(
   memmove
   SRCS
     memmove.cpp
   HDRS
     memmove.h
   DEPENDS
     libc.src.__support.integer_operations
-    libc.src.string.memcpy
+    .memory_utils.memcpy_implementation
 )
 
 add_entrypoint_object(
   memrchr
   SRCS
     memrchr.cpp
   HDRS
     memrchr.h

 
 add_entrypoint_object(
   stpncpy
   SRCS
     stpncpy.cpp
   HDRS
     stpncpy.h
   DEPENDS
-    .bzero
+    .memory_utils.memset_implementation
 )
 
 add_entrypoint_object(
   strcat
   SRCS
     strcat.cpp
   HDRS
     strcat.h

 
 add_entrypoint_object(
   strcpy
   SRCS
     strcpy.cpp
   HDRS
     strcpy.h
   DEPENDS
-    .memcpy
+    .memory_utils.memcpy_implementation
     .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
-    .memcpy
+    .memory_utils.memcpy_implementation
     .string_utils
     libc.include.stdlib
 )
 
 add_entrypoint_object(
   strlen
   SRCS
     strlen.cpp

 
 add_entrypoint_object(
   strndup
   SRCS
     strndup.cpp
   HDRS
     strndup.h
   DEPENDS
-    .memcpy
+    .memory_utils.memcpy_implementation
     .string_utils
     libc.include.stdlib
 )
 
 add_entrypoint_object(
   strnlen
   SRCS
     strnlen.cpp

 # 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.memory_utils
+      .memory_utils.memset_implementation
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-bzero
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})

 # 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.memory_utils
+      .memory_utils.memcmp_implementation
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memcmp
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})

 # 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.memory_utils
+      .memory_utils.memcpy_implementation
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memcpy
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})

 # 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.memory_utils
+      .memory_utils.memset_implementation
       libc.include.string
     COMPILE_OPTIONS
       -fno-builtin-memset
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})

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/__support/common.h"
 #include "src/__support/integer_operations.h"
-#include "src/string/memcpy.h"
+#include "src/string/memory_utils/memcpy_implementations.h"
 #include <stddef.h> // size_t, ptrdiff_t
 
 namespace __llvm_libc {
 
 static inline void move_byte_forward(char *dest_m, const char *src_m,
                                      size_t count) {
   for (size_t offset = 0; count; --count, ++offset)
     dest_m[offset] = src_m[offset];
LLVM_LIBC_FUNCTION(void *, memmove,
   // If the distance between `src_c` and `dest_c` is equal to or greater
   // than `count` (integerAbs(src_c - dest_c) >= count), they would not overlap.
   // e.g.   greater     equal       overlapping
   //        [12345678]  [12345678]  [12345678]
   // src_c: [_ab_____]  [_ab_____]  [_ab_____]
   // dest_c:[_____yz_]  [___yz___]  [__yz____]
 
   // Call `memcpy` if `src_c` and `dest_c` do not overlap.
-  if (__llvm_libc::integerAbs(src_c - dest_c) >= static_cast<ptrdiff_t>(count))
-    return __llvm_libc::memcpy(dest_c, src_c, count);
+  if (__llvm_libc::integerAbs(src_c - dest_c) >=
+      static_cast<ptrdiff_t>(count)) {
+    inline_memcpy(dest_c, src_c, count);
+    return dest_c;
+  }
 
   // Overlapping cases.
   // If `dest_c` starts before `src_c` (dest_c < src_c), copy
   // forward(pointer add 1) from beginning to end.
   // If `dest_c` starts after `src_c` (dest_c > src_c), copy
   // backward(pointer add -1) from end to beginning.
   // If `dest_c` and `src_c` start at the same address (dest_c == src_c),
   // just return dest.

libc/src/string/memory_utils/CMakeLists.txt

 add_header_library(
   memory_utils
   HDRS
     utils.h
     elements.h
 )
+
+add_header_library(
+  memcpy_implementation
+  HDRS
+    memcpy_implementations.h
+  DEPS
+    .memory_utils
+)
+
+add_header_library(
+  memcmp_implementation
+  HDRS
+    memcmp_implementations.h
+  DEPS
+    .memory_utils
+)
+
+add_header_library(
+  memset_implementation
+  HDRS
+    memset_implementations.h
+  DEPS
+    .memory_utils
+)

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/memcpy.h"
+#include "src/string/memory_utils/memcpy_implementations.h"
 
 #include "src/__support/common.h"
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void *, mempcpy,
                    (void *__restrict dest, const void *__restrict src,
                     size_t count)) {
-  void *result = __llvm_libc::memcpy(dest, src, count);
-  return result == nullptr
-             ? result
-             : static_cast<void *>(static_cast<char *>(result) + count);
+  if (dest == nullptr)
+    return nullptr;
+  char *result = reinterpret_cast<char *>(dest);
+  inline_memcpy(result, reinterpret_cast<const char *>(src), count);
+  return static_cast<void *>(result + count);
 }
 
 } // 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/bzero.h"
+#include "src/string/memory_utils/memset_implementations.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, stpncpy,
                    (char *__restrict dest, const char *__restrict src,
                     size_t n)) {
   size_t i;
   // Copy up until \0 is found.
   for (i = 0; i < n && src[i] != '\0'; ++i)
     dest[i] = src[i];
   // When n>strlen(src), n-strlen(src) \0 are appended.
   if (n > i)
-    __llvm_libc::bzero(dest + i, n - i);
+    inline_memset(dest + i, 0, n - i);
   return dest + i;
 }
 
 } // 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/memcpy.h"
+#include "src/string/memory_utils/memcpy_implementations.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 #include "src/__support/sanitizer.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strcpy,
                    (char *__restrict dest, const char *__restrict src)) {
   size_t size = internal::string_length(src) + 1;
-  char *result = reinterpret_cast<char *>(__llvm_libc::memcpy(dest, src, size));
+  inline_memcpy(dest, src, size);
 
   // In many libc uses, we do not want memcpy to be instrumented. Hence,
   // we mark the destination as initialized.
   //
   // We do not want memcpy to be instrumented because compilers can potentially
   // generate calls to memcpy. If the sanitizer business logic ends up with a
   // compiler generated call to memcpy which is instrumented, then it will
   // break the sanitizers.
-  SANITIZER_MEMORY_INITIALIZED(result, size);
+  SANITIZER_MEMORY_INITIALIZED(dst, size);
 
-  return result;
+  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/string/memcpy.h"
+#include "src/string/memory_utils/memcpy_implementations.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strdup, (const char *src)) {
   if (src == nullptr) {
     return nullptr;
   }
   size_t len = internal::string_length(src) + 1;
   char *dest = reinterpret_cast<char *>(::malloc(len)); // NOLINT
   if (dest == nullptr) {
     return nullptr;
   }
-  char *result = reinterpret_cast<char *>(__llvm_libc::memcpy(dest, src, len));
-  return result;
+  inline_memcpy(dest, src, len);
+  return dest;
 }
 
 } // 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/memcpy.h"
+#include "src/string/memory_utils/memcpy_implementations.h"
 #include "src/string/string_utils.h"
 
 #include "src/__support/common.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strndup, (const char *src, size_t size)) {
   if (src == nullptr)
     return nullptr;
   size_t len = internal::string_length(src);
   if (len > size)
     len = size;
   char *dest = reinterpret_cast<char *>(::malloc(len + 1)); // NOLINT
   if (dest == nullptr)
     return nullptr;
-  char *result =
-      reinterpret_cast<char *>(__llvm_libc::memcpy(dest, src, len + 1));
-  result[len] = '\0';
-  return result;
+  inline_memcpy(dest, src, len + 1);
+  dest[len] = '\0';
+  return dest;
 }
 
 } // namespace __llvm_libc