[libc][benchmarks] Link the memory benchmark exes to functions from LLVM libc.

[sivachandra]

Summary

To get the target order correct, the benchmarks directory has been moved
one level higher. Previously, it was living in the utils directory. The
utils directory is a collection of utils which are to be used by the
tests and implementations. However, benchmarks *use* the
implementations. So, moving it out of utils helps us setup proper
target level dependencies.

[gchatelet]

LGTM

libc/CMakeLists.txt

 # The lib and test directories are added at the very end as tests
 # and libraries potentially draw from the components present in all
 # of the other directories.
 add_subdirectory(lib)
 if(LLVM_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(fuzzing)
 endif()
+
+add_subdirectory(benchmarks)

libc/benchmarks/CMakeLists.txt

function(add_libc_benchmark_configuration target configuration)
     set(run_target run-${conf_target})
     add_custom_target(${run_target}
         COMMAND ${libc_target} --conf=configuration_${configuration}.json -o ${json_file}
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     )
     add_libc_benchmark_analysis(${conf_target} ${run_target})
 endfunction()
 
-function(add_libc_benchmark name file)
+function(add_libc_benchmark name file entrypoint_target)
     set(libc_target libc-${name}-benchmark)
     add_executable(${libc_target}
         EXCLUDE_FROM_ALL
         ${file}
         LibcMemoryBenchmarkMain.h
         LibcMemoryBenchmarkMain.cpp
     )
-    target_link_libraries(${libc_target} PUBLIC json)
+
+    get_target_property(entrypoint_object_file ${entrypoint_target} "OBJECT_FILE_RAW")
+    target_link_libraries(${libc_target} PUBLIC json ${entrypoint_object_file})
     foreach(configuration "small" "big")
         add_libc_benchmark_configuration(${libc_target} ${configuration})
     endforeach()
 endfunction()
 
-add_libc_benchmark(memcpy Memcpy.cpp)
-add_libc_benchmark(memcmp Memcmp.cpp)
-add_libc_benchmark(memset Memset.cpp)
+add_libc_benchmark(memcpy Memcpy.cpp libc.src.string.memcpy)
+add_libc_benchmark(memset Memset.cpp libc.src.string.memset)

libc/benchmarks/Memcpy.cpp

 //===-- Benchmark memcpy implementation -----------------------------------===//
 //
 // 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 "LibcBenchmark.h"
 #include "LibcMemoryBenchmark.h"
 #include "LibcMemoryBenchmarkMain.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
+namespace __llvm_libc {
+extern void *memcpy(void *__restrict, const void *__restrict, size_t);
+} // namespace __llvm_libc
+
 namespace llvm {
 namespace libc_benchmarks {
 
 // The context encapsulates the buffers, parameters and the measure.
 struct MemcpyContext : public BenchmarkRunner {
   using FunctionPrototype = void *(*)(void *, const void *, size_t);
 
   struct ParameterType {

libc/benchmarks/Memset.cpp

 //===-- Benchmark memset implementation -----------------------------------===//
 //
 // 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 "LibcBenchmark.h"
 #include "LibcMemoryBenchmark.h"
 #include "LibcMemoryBenchmarkMain.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace __llvm_libc {
+void *memset(void *, int, size_t);
+} // namespace __llvm_libc
+
 namespace llvm {
 namespace libc_benchmarks {
 
 // The context encapsulates the buffers, parameters and the measure.
 struct MemsetContext : public BenchmarkRunner {
   using FunctionPrototype = void *(*)(void *, int, size_t);
 
   struct ParameterType {
struct MemsetContext : public BenchmarkRunner {
 
   ArrayRef<StringRef> getFunctionNames() const override {
     static std::array<StringRef, 1> kFunctionNames = {"memset"};
     return kFunctionNames;
   }
 
   BenchmarkResult benchmark(const BenchmarkOptions &Options,
                             StringRef FunctionName, size_t Size) override {
-    FunctionPrototype Function =
-        StringSwitch<FunctionPrototype>(FunctionName).Case("memset", &::memset);
+    FunctionPrototype Function = StringSwitch<FunctionPrototype>(FunctionName)
+                                     .Case("memset", &__llvm_libc::memset);
     return llvm::libc_benchmarks::benchmark(
         Options, PP, [this, Function, Size](ParameterType p) {
           Function(DstBuffer + p.DstOffset, MemsetValue, Size);
           return DstBuffer + p.DstOffset;
         });
   }
 
 private:

libc/utils/CMakeLists.txt

 add_subdirectory(CPP)
 add_subdirectory(FPUtil)
 add_subdirectory(HdrGen)
 add_subdirectory(MPFRWrapper)
 add_subdirectory(testutils)
 add_subdirectory(UnitTest)
-add_subdirectory(benchmarks)