[libc] Apply no-builtin everywhere, remove unnecessary flags

[gchatelet]

Summary

Note, this is a re-submission of D125894 with features = ["-header_modules"]
added to the main BUILD.bazel file.

Some functions like stpncpy are implemented in terms of memset but are not
currently using -fno-builtin-memset. This is somewhat hidden by the fact that
we use -ffreestanding globally and that -ffreestanding implies
-fno-builtin for Clang.

This patch also removes -mllvm -combiner-global-alias-analysis that is Clang
specific and that does not bring substantial gains on modern processors.

Also we keep -mllvm --tail-merge-threshold=0 for aarch64 in CMakeLists.txt
but we omit it in the Bazel config. This is because Bazel consumes the source
files directly and so it can use PGO to take optimal decisions locally.

libc/cmake/modules/LLVMLibCObjectRules.cmake

 set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
 
 function(_get_common_compile_options output_var)
   set(compile_options ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN})
   if(NOT ${LIBC_TARGET_OS} STREQUAL "windows")
-    set(compile_options ${compile_options} -fpie -ffreestanding)
+    set(compile_options ${compile_options} -fpie -ffreestanding -fno-builtin)
   endif()
   if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
     list(APPEND compile_options "-fno-exceptions")
     list(APPEND compile_options "-fno-unwind-tables")
     list(APPEND compile_options "-fno-asynchronous-unwind-tables")
     list(APPEND compile_options "-fno-rtti")
   elseif(MSVC)
     list(APPEND compile_options "/EHs-c-")

libc/src/string/CMakeLists.txt

function(add_implementation name impl_name)
   cmake_parse_arguments(
     "ADD_IMPL"
     "" # Optional arguments
     "" # Single value arguments
     "REQUIRE;SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;MLLVM_COMPILE_OPTIONS" # Multi value arguments
     ${ARGN})
 
   if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-    list(APPEND ADD_IMPL_MLLVM_COMPILE_OPTIONS "-combiner-global-alias-analysis")
     # Note that '-mllvm' needs to be prefixed with 'SHELL:' to prevent CMake flag deduplication.
     foreach(opt IN LISTS ADD_IMPL_MLLVM_COMPILE_OPTIONS)
       list(APPEND ADD_IMPL_COMPILE_OPTIONS "SHELL:-mllvm ${opt}")
     endforeach()
   endif()
 
   add_entrypoint_object(${impl_name}
     NAME ${name}

 
 function(add_bcmp bcmp_name)
   add_implementation(bcmp ${bcmp_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/bcmp.cpp
     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})
   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)

 
 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.memset_implementation
       libc.include.string
-    COMPILE_OPTIONS
-      -fno-builtin-bzero
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_bzero(bzero_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_bzero(bzero_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_bzero(bzero_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)

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

 
 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.memcpy_implementation
       libc.include.string
-    COMPILE_OPTIONS
-      -fno-builtin-memcpy
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memcpy(memcpy_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memcpy(memcpy_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memcpy(memcpy_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)

 
 function(add_memmove memmove_name)
   add_implementation(memmove ${memmove_name}
     SRCS ${LIBC_SOURCE_DIR}/src/string/memmove.cpp
     HDRS ${LIBC_SOURCE_DIR}/src/string/memmove.h
     DEPENDS
       .memory_utils.memory_utils
       libc.include.string
-    COMPILE_OPTIONS
-      -fno-builtin
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memmove(memmove_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memmove(memmove_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memmove(memmove_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)

 
 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.memset_implementation
       libc.include.string
-    COMPILE_OPTIONS
-      -fno-builtin-memset
     ${ARGN}
   )
 endfunction()
 
 if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_memset(memset_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
   add_memset(memset_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
   add_memset(memset_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

 # This file is licensed 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
 
 # LLVM libc project.
 load(":libc_build_rules.bzl", "libc_function", "libc_math_function")
 load(":platforms.bzl", "PLATFORM_CPU_ARM64", "PLATFORM_CPU_X86_64")
 load("@bazel_skylib//lib:selects.bzl", "selects")
 
 package(
     default_visibility = ["//visibility:public"],
+    features = ["-header_modules"],
     licenses = ["notice"],
 )
 
 # This empty root library helps us add an include path to this directory
 # using the 'includes' attribute. The strings listed in the includes attribute
 # are relative paths wrt this library but are inherited by the dependents
 # appropriately. Hence, using this as a root dependency avoids adding include
 # paths of the kind "../../" to other libc targets.
cc_library(
     deps = [":libc_root"],
 )
 
 cc_library(
     name = "__support_cpp_uint",
     hdrs = [
         "src/__support/CPP/UInt.h",
     ],
-    deps = [":libc_root","__support_cpp_array"],
+    deps = [
+        "__support_cpp_array",
+        ":libc_root",
+    ],
 )
 
 cc_library(
     name = "__support_cpp_type_traits",
     hdrs = [
         "src/__support/CPP/TypeTraits.h",
     ],
-    deps = [":libc_root","__support_cpp_uint"],
+    deps = [
+        "__support_cpp_uint",
+        ":libc_root",
+    ],
 )
 
 cc_library(
     name = "__support_cpp_utility",
     hdrs = ["src/__support/CPP/Utility.h"],
     deps = [
         ":__support_cpp_type_traits",
         ":libc_root",
deps = [
         ":string_utils",
     ],
 )
 
 libc_function(
     name = "memcpy",
     srcs = ["src/string/memcpy.cpp"],
     hdrs = ["src/string/memcpy.h"],
-    copts = [
-        "-fno-builtin-memcpy",
-        "-fno-builtin-memmove",
-        "-mllvm -combiner-global-alias-analysis",
-        "-mllvm --tail-merge-threshold=0",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":string_memory_utils",
     ],
 )
 
 libc_function(
     name = "memset",
     srcs = ["src/string/memset.cpp"],
     hdrs = ["src/string/memset.h"],
-    copts = [
-        "-fno-builtin-memset",
-        "-mllvm -combiner-global-alias-analysis",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":string_memory_utils",
     ],
 )
 
 libc_function(
     name = "memmove",
     srcs = ["src/string/memmove.cpp"],
     hdrs = ["src/string/memmove.h"],
-    copts = [
-        "-fno-builtin-memmove",
-        "-mllvm -combiner-global-alias-analysis",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":__support_integer_operations",
         ":memcpy",
         ":string_memory_utils",
     ],
 )
 
 libc_function(
     name = "memcmp",
     srcs = ["src/string/memcmp.cpp"],
     hdrs = ["src/string/memcmp.h"],
-    copts = [
-        "-fno-builtin-memcmp",
-        "-mllvm -combiner-global-alias-analysis",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":__support_integer_operations",
         ":string_memory_utils",
     ],
 )
 
 libc_function(
     name = "bcmp",
     srcs = ["src/string/bcmp.cpp"],
     hdrs = ["src/string/bcmp.h"],
-    copts = [
-        "-fno-builtin-bcmp",
-        "-fno-builtin-memcmp",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":string_memory_utils",
     ],
 )
 
 libc_function(
     name = "bzero",
     srcs = ["src/string/bzero.cpp"],
     hdrs = ["src/string/bzero.h"],
-    copts = [
-        "-fno-builtin-bzero",
-        "-fno-builtin-memset",
-        "-mllvm -combiner-global-alias-analysis",
-    ],
     features = no_sanitize_features,
     deps = [
         ":__support_common",
         ":string_memory_utils",
     ],
 )
 
 libc_function(

utils/bazel/llvm-project-overlay/libc/libc_build_rules.bzl

Args:
       deps: The list of target dependencies if any.
       copts: The list of options to add to the C++ compilation command.
       **kwargs: Other attributes relevant for a cc_library. For example, deps.
     """
     deps = deps or []
     deps.append(LIBC_ROOT_TARGET)
     copts = copts or []
     copts.append("-O3")
+    copts.append("-fno-builtin")
 
     # We compile the code twice, the first target is suffixed with ".__internal__" and contains the
     # C++ functions in the "__llvm_libc" namespace. This allows us to test the function in the
     # presence of another libc.
     native.cc_library(
         name = name + INTERNAL_SUFFIX,
         srcs = srcs,
         deps = deps,