[libc] Allow target architecture customization

[gchatelet]

Summary

This patch provides a way to specify the default target cpu optimizations to use when compiling llvm-libc.
This ensures we don't rely on current compiler's default and allows compiling and cross compiling for a particular target.

[gchatelet]

• Fix formatting

[gchatelet]

• include both commits

[sivachandra]

libc/cmake/modules/LLVMLibCLibraryRules.cmake

85

We should not need to set compile options here. If you notice, the add_library rule on line 79 does not compile anything. It just packs a bunch of object files into a static archive.

114

Same here as well. We should not need to set compile options.

libc/cmake/modules/LLVMLibCObjectRules.cmake

151

While you are at it, can you fix this: we should use the same default compile options for add_entrypoint_object and add_object_library above. So, essentially, I am saying that we should be sharing common_compiler_options between these two rules.

[gchatelet]

• Remove unnecessary target_compile_options
• Use same common compile options between add_entrypoint_object and add_object_library

[sivachandra]

libc/cmake/modules/LLVMLibCObjectRules.cmake

44

Instead of _set_*, I think a function with name _get_* will be more appropriate here. The function should also take an additional arg for the result:

_get_all_compile_options(all_opts ...)
target_compile_options(${fq_target_name} PRIVATE ${all_opts})

This probably a nitty comment but motivated by the fact that common is not suitable in add_object_library.

[gchatelet]

libc/cmake/modules/LLVMLibCObjectRules.cmake

44

I was pondering whether get or set was more suitable and I've been lazy : )
Thx for the comment it makes sense to go with get indeed.

libc/CMakeLists.txt

 set(LIBC_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE PATH "Define libc destination prefix.")
 
 set(LIBC_TARGET_OS ${CMAKE_SYSTEM_NAME})
 string(TOLOWER ${LIBC_TARGET_OS} LIBC_TARGET_OS)
 
 # Defines LIBC_TARGET_ARCHITECTURE and associated macros.
 include(LLVMLibCArchitectures)
 
+# Flags to pass down to the compiler while building the libc functions.
+set(LIBC_COMPILE_OPTIONS_DEFAULT "" CACHE STRING "Architecture to tell clang to optimize for (e.g. -march=... or -mcpu=...)")
+
 # Check --print-resource-dir to find the compiler resource dir if this flag
 # is supported by the compiler.
 execute_process(
   OUTPUT_STRIP_TRAILING_WHITESPACE
   COMMAND ${CMAKE_CXX_COMPILER} --print-resource-dir
   RESULT_VARIABLE COMMAND_RETURN_CODE
   OUTPUT_VARIABLE COMPILER_RESOURCE_DIR
 )

libc/cmake/modules/LLVMLibCLibraryRules.cmake

function(add_entrypoint_library target_name)
   foreach(dep IN LISTS all_deps)
     list(APPEND objects $<TARGET_OBJECTS:${dep}>)
   endforeach(dep)
   add_library(
     ${target_name}
     STATIC
     ${objects}
   )
-  set_target_properties(
-    ${target_name}
-    PROPERTIES
-      ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-  )
+  set_target_properties(${target_name}  PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 endfunction(add_entrypoint_library)
 
 # Rule to build a shared library of redirector objects.
 function(add_redirector_library target_name)
   cmake_parse_arguments(
     "REDIRECTOR_LIBRARY"
     ""
     ""
     "DEPENDS"
function(add_redirector_library target_name)
   # TODO: Call the linker explicitly instead of calling the compiler driver to
   # prevent DT_NEEDED on C++ runtime.
   add_library(
     ${target_name}
     EXCLUDE_FROM_ALL
     SHARED
     ${obj_files}
   )
-  set_target_properties(${target_name} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-  target_link_libraries(
-    ${target_name}
-    -nostdlib -lc -lm
-  )
-
-  set_target_properties(
-    ${target_name}
-    PROPERTIES
-      LINKER_LANGUAGE "C"
-  )
+  set_target_properties(${target_name}  PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  target_link_libraries(${target_name}  -nostdlib -lc -lm)
+  set_target_properties(${target_name}  PROPERTIES LINKER_LANGUAGE "C")
 endfunction(add_redirector_library)
 
 set(HDR_LIBRARY_TARGET_TYPE "HDR_LIBRARY")
 
 # Rule to add header only libraries.
 # Usage
 #    add_header_library(
 #      <target name>
 #      HDRS  <list of .h files part of the library>

libc/cmake/modules/LLVMLibCObjectRules.cmake

 set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
 
+function(_set_common_compile_options)
+  set(LIBC_COMMON_COMPILE_OPTIONS -fpie ${LLVM_CXX_STD_default} -ffreestanding ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN} PARENT_SCOPE)
+endfunction()
+
 # Rule which is essentially a wrapper over add_library to compile a set of
 # sources to object files.
 # Usage:
 #     add_object_library(
 #       <target_name>
 #       HDRS <list of header files>
 #       SRCS <list of source files>
 #       DEPENDS <list of dependencies>
function(add_object_library target_name)
   )
   target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_BUILD_DIR}/include
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
   )
-  if(ADD_OBJECT_COMPILE_OPTIONS)
-    target_compile_options(
-      ${fq_target_name}
-      PRIVATE ${ADD_OBJECT_COMPILE_OPTIONS}
-    )
-  endif()
+  _set_common_compile_options(${ADD_OBJECT_COMPILE_OPTIONS})
+  target_compile_options(${fq_target_name} PRIVATE ${LIBC_COMMON_COMPILE_OPTIONS})
 
   get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
   if(fq_deps_list)
     add_dependencies(${fq_target_name} ${fq_deps_list})
   endif()
 
   set_target_properties(
     ${fq_target_name}
function(add_entrypoint_object target_name)
 
   if(NOT ADD_ENTRYPOINT_OBJ_SRCS)
     message(FATAL_ERROR "`add_entrypoint_object` rule requires SRCS to be specified.")
   endif()
   if(NOT ADD_ENTRYPOINT_OBJ_HDRS)
     message(FATAL_ERROR "`add_entrypoint_object` rule requires HDRS to be specified.")
   endif()
 
-  set(common_compile_options -fpie ${LLVM_CXX_STD_default} -ffreestanding ${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS})
+  _set_common_compile_options(${ADD_ENTRYPOINT_OBJ_COMPILE_OPTIONS})
   set(internal_target_name ${fq_target_name}.__internal__)
   set(include_dirs ${LIBC_BUILD_DIR}/include ${LIBC_SOURCE_DIR} ${LIBC_BUILD_DIR})
   get_fq_deps_list(fq_deps_list ${ADD_ENTRYPOINT_OBJ_DEPENDS})
   set(full_deps_list ${fq_deps_list} libc.src.__support.common)
 
   add_library(
     ${internal_target_name}
     # TODO: We don't need an object library for internal consumption.
     # A future change should switch this to a normal static library.
     EXCLUDE_FROM_ALL
     OBJECT
     ${ADD_ENTRYPOINT_OBJ_SRCS}
     ${ADD_ENTRYPOINT_OBJ_HDRS}
   )
-  target_compile_options(${internal_target_name} BEFORE PRIVATE ${common_compile_options})
+  target_compile_options(${internal_target_name} BEFORE PRIVATE ${LIBC_COMMON_COMPILE_OPTIONS})
   target_include_directories(${internal_target_name} PRIVATE ${include_dirs})
   add_dependencies(${internal_target_name} ${full_deps_list})
 
   add_library(
     ${fq_target_name}
     # We want an object library as the objects will eventually get packaged into
     # an archive (like libc.a).
     EXCLUDE_FROM_ALL
     OBJECT
     ${ADD_ENTRYPOINT_OBJ_SRCS}
     ${ADD_ENTRYPOINT_OBJ_HDRS}
   )
-  target_compile_options(
-      ${fq_target_name} BEFORE PRIVATE ${common_compile_options} -DLLVM_LIBC_PUBLIC_PACKAGING
-  )
+  target_compile_options(${fq_target_name} BEFORE PRIVATE ${LIBC_COMMON_COMPILE_OPTIONS} -DLLVM_LIBC_PUBLIC_PACKAGING)
   target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
   add_dependencies(${fq_target_name} ${full_deps_list})
 
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
       "ENTRYPOINT_NAME" ${entrypoint_name}
       "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
function(add_redirector_object target_name)
   add_library(
     ${target_name}
     EXCLUDE_FROM_ALL
     OBJECT
     ${REDIRECTOR_OBJECT_SRC}
   )
   target_compile_options(
     ${target_name}
-    BEFORE PRIVATE -fPIC
+    BEFORE PRIVATE -fPIC ${LIBC_COMPILE_OPTIONS_DEFAULT}
   )
 endfunction(add_redirector_object)

libc/cmake/modules/LLVMLibCTestRules.cmake

function(add_libc_unittest target_name)
   )
   target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
       ${LIBC_BUILD_DIR}/include
   )
+  target_compile_options(
+    ${fq_target_name}
+    PRIVATE ${LIBC_COMPILE_OPTIONS_DEFAULT}
+  )
   if(LIBC_UNITTEST_COMPILE_OPTIONS)
     target_compile_options(
       ${fq_target_name}
       PRIVATE ${LIBC_UNITTEST_COMPILE_OPTIONS}
     )
   endif()
 
   target_link_libraries(${fq_target_name} PRIVATE ${link_object_files})