[libc] Add aliases to C memory functions for integration tests

[jhuber6]

Summary

The integration tests require the C memory functions as the compiler may
emit calls to them directly. The tests normally use the __internal__
variant that is built for testing, but these memory functions were
linked directly to preserve the entrypoint. Instead, we forward delcare
the internal versions and map the entrypoints to them manually inside
the integration test. This allows us to use the internal versions of
these files like the rest of the test objects.

[michaelrj]

libc/cmake/modules/LLVMLibCTestRules.cmake

450–452

if these appends are both done unconditionally to the same list they can probably be combined.

[jhuber6]

libc/cmake/modules/LLVMLibCTestRules.cmake

450–452

Soon I'm going to try to add the GPU integration test support, which will be different. I think we should make the former inherit all the dependencies from the STARTUP argument. What do you think @sivachandra?

[sivachandra]

libc/cmake/modules/LLVMLibCTestRules.cmake

450–452

Yes, that would be good. You can still combine them into a single APPEND operation and add some comment about why the memory functions are being added - a modified version of what was present on lines 477 to 480.

libc/test/IntegrationTest/test.cpp

29

Nit: Empty lines between the definitions to improve readability.

[jhuber6]

Merging the dependency list and addressing comments. I'll try to remove the other dependencies by picking them up from the startup in a later patch.

libc/cmake/modules/LLVMLibCTestRules.cmake

list(APPEND fq_deps_list
       # All integration tests setup TLS area and the main thread's self object.
       # So, we need to link in the threads implementation. Likewise, the startup
       # code also has to run init_array callbacks which potentially register
       # their own atexit callbacks. So, link in exit and atexit also with all
       # integration tests.
       libc.src.__support.threads.thread
       libc.src.stdlib.atexit
       libc.src.stdlib.exit
       libc.src.unistd.environ
-  )
-  list(APPEND memory_functions
+      # We always add the memory functions objects. This is because the
+      # compiler's codegen can emit calls to the C memory functions.
       libc.src.string.bcmp
       libc.src.string.bzero
       libc.src.string.memcmp
       libc.src.string.memcpy
       libc.src.string.memmove
       libc.src.string.memset
   )
-  # We remove the memory function deps because we want to explicitly add the
-  # object files which include the public symbols of the memory functions.
-  list(REMOVE_ITEM fq_deps_list ${memory_functions})
   list(REMOVE_DUPLICATES fq_deps_list)
 
   # TODO: Instead of gathering internal object files from entrypoints,
   # collect the object files with public names of entrypoints.
   get_object_files_for_test(
       link_object_files skipped_entrypoints_list ${fq_deps_list})
   if(skipped_entrypoints_list)
     if(LIBC_CMAKE_VERBOSE_LOGGING)
       set(msg "Skipping unittest ${fq_target_name} as it has missing deps: "
               "${skipped_entrypoints_list}.")
       message(STATUS ${msg})
     endif()
     return()
   endif()
-  # We add the memory functions objects explicitly. Note that we
-  # are adding objects of the targets which contain the public
-  # C symbols. This is because compiler codegen can emit calls to
-  # the C memory functions.
-  foreach(func IN LISTS memory_functions)
-    list(APPEND link_object_files $<TARGET_OBJECTS:${func}>)
-  endforeach()
   list(REMOVE_DUPLICATES link_object_files)
 
   # Make a library of all deps
   add_library(
     ${fq_target_name}.__libc__
     STATIC
     EXCLUDE_FROM_ALL
     ${link_object_files}

libc/test/IntegrationTest/test.cpp

 //===-- Simple malloc and free for use with integration tests -------------===//
 //
 // 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 <stddef.h>
 #include <stdint.h>
 
+// Integration tests rely on the following memory functions. This is because the
+// compiler code generation can emit calls to them. We want to map the external
+// entrypoint to the internal implementation of the function used for testing.
+// This is done manually as not all targets support aliases.
+
+namespace __llvm_libc {
+
+int bcmp(const void *lhs, const void *rhs, size_t count);
+void bzero(void *ptr, size_t count);
+int memcmp(const void *lhs, const void *rhs, size_t count);
+void *memcpy(void *__restrict, const void *__restrict, size_t);
+void *memmove(void *dst, const void *src, size_t count);
+void *memset(void *ptr, int value, size_t count);
+
+} // namespace __llvm_libc
+
+extern "C" {
+
+int bcmp(const void *lhs, const void *rhs, size_t count) {
+  __llvm_libc::bcmp(lhs, rhs, count);
+}
+void bzero(void *ptr, size_t count) { __llvm_libc::bzero(ptr, count); }
+int memcmp(const void *lhs, const void *rhs, size_t count) {
+  __llvm_libc::memcmp(lhs, rhs, count);
+}
+void *memcpy(void *__restrict dst, const void *__restrict src, size_t count) {
+  __llvm_libc::memcpy(dst, src, count);
+}
+void *memmove(void *dst, const void *src, size_t count) {
+  __llvm_libc::memmove(dst, src, count);
+}
+void *memset(void *ptr, int value, size_t count) {
+  __llvm_libc::memset(ptr, value, count);
+}
+
+} // extern "C"
+
 // Integration tests cannot use the SCUDO standalone allocator as SCUDO pulls
 // various other parts of the libc. Since SCUDO development does not use
 // LLVM libc build rules, it is very hard to keep track or pull all that SCUDO
 // requires. Hence, as a work around for this problem, we use a simple allocator
 // which just hands out continuous blocks from a statically allocated chunk of
 // memory.
 
 static uint8_t memory[16384];