[libc] Implement FLAGS option for generating all combinations for targets.

[lntue]

Summary

Add FLAGS option for add_header_library, add_object_library,
add_entrypoint_object, and add_libc_unittest.

In general, a flag is a string provided for supported functions under the
multi-valued option FLAGS. It should be one of the following forms:

FLAG_NAME
FLAG_NAME__NO
FLAG_NAME__ONLY

A target will inherit all the flags of its upstream dependency.

When we create a target TARGET_NAME with a flag using (add_header_library,
add_object_library, ...), its behavior will depend on the flag form as follow:

• FLAG_NAME: The following 2 targets will be generated: TARGET_NAME that has FLAG_NAME in its FLAGS property. TARGET_NAME.__NO_FLAG_NAME that depends on DEP.__NO_FLAG_NAME if TARGET_NAME depends on DEP and DEP has FLAG_NAME in its FLAGS property.
• FLAG_NAME__ONLY: Only generate 1 target TARGET_NAME that has FLAG_NAME in its FLAGS property.
• FLAG_NAME__NO: Only generate 1 target TARGET_NAME.__NO_FLAG_NAME that depends on DEP.__NO_FLAG_NAME if DEP is in its DEPENDS list and DEP has FLAG_NAME in its FLAGS property.

To show all the targets generated, pass SHOW_INTERMEDIATE_OBJECTS=ON to cmake.
To show all the targets' dependency and flags, pass
SHOW_INTERMEDIATE_OBJECTS=DEPS to cmake.

To completely disable a flag FLAG_NAME expansion, set the variable
SKIP_FLAG_EXPANSION_FLAG_NAME=TRUE.

[lntue]

Sync.

[lntue]

Let add_header_library work properly with flagONLY and flagNO options.

[lntue]

Add SKIP_FLAG_EXPASION_* option and clean up some DEPENDS options ordering.

[lntue]

Fix small bugs.

[michaelrj]

LGTM

[sivachandra]

Go ahead and land it. It is not ideal, but we will try to adjust as we learn more.

libc/CMakeLists.txt

if(LLVM_LIBC_INCLUDE_SCUDO)
   if (NOT "compiler-rt" IN_LIST LLVM_ENABLE_PROJECTS)
     message(FATAL_ERROR "SCUDO cannot be included without adding compiler-rt to LLVM_ENABLE_PROJECTS")
   endif()
 endif()
 
 option(LIBC_INCLUDE_DOCS "Build the libc documentation." ${LLVM_INCLUDE_DOCS})
 
 include(CMakeParseArguments)
-include(LLVMLibCRules)
 include(LLVMLibCCheckCpuFeatures)
+include(LLVMLibCRules)
 
 if(EXISTS "${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}/entrypoints.txt")
   set(entrypoint_file "${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}/entrypoints.txt")
 elseif(EXISTS "${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/entrypoints.txt")
   set(entrypoint_file "${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/entrypoints.txt")
 else()
   message(FATAL_ERROR "entrypoints.txt file for the target platform '${LIBC_TARGET_OS}/${LIBC_TARGET_ARCHITECTURE}' not found.")
 endif()

libc/cmake/modules/LLVMLibCFlagRules.cmake

+# In general, a flag is a string provided for supported functions under the
+# multi-valued option `FLAGS`.  It should be one of the following forms:
+#   FLAG_NAME
+#   FLAG_NAME__NO
+#   FLAG_NAME__ONLY
+# A target will inherit all the flags of its upstream dependency.
+#
+# When we create a target `TARGET_NAME` with a flag using (add_header_library,
+# add_object_library, ...), its behavior will depend on the flag form as follow:
+# - FLAG_NAME: The following 2 targets will be generated:
+#     `TARGET_NAME` that has `FLAG_NAME` in its `FLAGS` property.
+#     `TARGET_NAME.__NO_FLAG_NAME` that depends on `DEP.__NO_FLAG_NAME` if
+#        `TARGET_NAME` depends on `DEP` and `DEP` has `FLAG_NAME` in its `FLAGS`
+#        property.
+# - FLAG_NAME__ONLY: Only generate 1 target `TARGET_NAME` that has `FLAG_NAME`
+#     in its `FLAGS` property.
+# - FLAG_NAME__NO: Only generate 1 target `TARGET_NAME` that depends on
+# `DEP.__NO_FLAG_NAME` if `DEP` is in its DEPENDS list and `DEP` has `FLAG_NAME`
+# in its `FLAGS` property.
+#
+# To show all the targets generated, pass SHOW_INTERMEDIATE_OBJECTS=ON to cmake.
+# To show all the targets' dependency and flags, pass
+#   SHOW_INTERMEDIATE_OBJECTS=DEPS to cmake.
+#
+# To completely disable a flag FLAG_NAME expansion, set the variable
+#   SKIP_FLAG_EXPANSION_FLAG_NAME=TRUE in this file.
+
+
+function(extract_flag_modifier input_flag output_flag modifier)
+  if(${input_flag} MATCHES "__NO$")
+    string(REGEX REPLACE "__NO$" "" flag "${input_flag}")
+    set(${output_flag} ${flag} PARENT_SCOPE)
+    set(${modifier} "NO" PARENT_SCOPE)
+  elseif(${input_flag} MATCHES "__ONLY$")
+    string(REGEX REPLACE "__ONLY$" "" flag "${input_flag}")
+    set(${output_flag} ${flag} PARENT_SCOPE)
+    set(${modifier} "ONLY" PARENT_SCOPE)
+  else()
+    set(${output_flag} ${input_flag} PARENT_SCOPE)
+    set(${modifier} "" PARENT_SCOPE)
+  endif()
+endfunction(extract_flag_modifier)
+
+function(remove_duplicated_flags input_flags output_flags)
+  set(out_flags "")
+  foreach(input_flag IN LISTS input_flags)
+    if(NOT input_flag)
+      continue()
+    endif()
+
+    extract_flag_modifier(${input_flag} flag modifier)
+
+    # Check if the flag is skipped.
+    if(${SKIP_FLAG_EXPANSION_${flag}})
+      if("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS")
+        message(STATUS "  Flag ${flag} is ignored.")
+      endif()
+      continue()
+    endif()
+
+    set(found FALSE)
+    foreach(out_flag IN LISTS out_flags)
+      extract_flag_modifier(${out_flag} o_flag o_modifier)
+      if("${flag}" STREQUAL "${o_flag}")
+        set(found TRUE)
+        break()
+      endif()
+    endforeach()
+    if(NOT found)
+      list(APPEND out_flags ${input_flag})
+    endif()
+  endforeach()
+
+  set(${output_flags} "${out_flags}" PARENT_SCOPE)
+endfunction(remove_duplicated_flags)
+
+# Collect flags from dependency list.  To see which flags come with each
+# dependence, pass `SHOW_INTERMEDIATE_OBJECTS=DEPS` to cmake.
+function(get_flags_from_dep_list output_list)
+  set(flag_list "")
+  foreach(dep IN LISTS ARGN)
+    if(NOT dep)
+      continue()
+    endif()
+
+    get_fq_dep_name(fq_dep_name ${dep})
+
+    if(NOT TARGET ${fq_dep_name})
+      continue()
+    endif()
+
+    get_target_property(flags ${fq_dep_name} "FLAGS")
+
+    if(flags AND "${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS")
+      message(STATUS "  FLAGS from dependency ${fq_dep_name} are ${flags}")
+    endif()
+
+    foreach(flag IN LISTS flags)
+      if(flag)
+        list(APPEND flag_list ${flag})
+      endif()
+    endforeach()
+  endforeach(dep)
+
+  list(REMOVE_DUPLICATES flag_list)
+
+  set(${output_list} ${flag_list} PARENT_SCOPE)
+endfunction(get_flags_from_dep_list)
+
+# Given a `flag` without modifier, scan through the list of dependency, append
+# `.__NO_flag` to any target that has `flag` in its FLAGS property.
+function(get_fq_dep_list_without_flag output_list flag)
+  set(fq_dep_no_flag_list "")
+  foreach(dep IN LISTS ARGN)
+    get_fq_dep_name(fq_dep_name ${dep})
+    if(TARGET ${fq_dep_name})
+      get_target_property(dep_flags ${fq_dep_name} "FLAGS")
+      # Only target with `flag` has `.__NO_flag` target, `flag__NO` and
+      # `flag__ONLY` do not.
+      if(${flag} IN_LIST dep_flags)
+        list(APPEND fq_dep_no_flag_list "${fq_dep_name}.__NO_${flag}")
+      else()
+        list(APPEND fq_dep_no_flag_list ${fq_dep_name})
+      endif()
+    else()
+      list(APPEND fq_dep_no_flag_list ${fq_dep_name})
+    endif()
+  endforeach(dep)
+  set(${output_list} ${fq_dep_no_flag_list} PARENT_SCOPE)
+endfunction(get_fq_dep_list_without_flag)
+
+# Special flags
+set(FMA_OPT_FLAG "FMA_OPT")

libc/cmake/modules/LLVMLibCLibraryRules.cmake

function(add_redirector_library target_name)
   )
   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>
-#      DEPENDS <list of dependencies>
-#    )
-function(add_header_library target_name)
+# Internal function, used by `add_header_library`.
+function(create_header_library fq_target_name)
   cmake_parse_arguments(
     "ADD_HEADER"
-    "" # No optional arguments
-    "" # No Single value arguments
-    "HDRS;DEPENDS" # Multi-value arguments
+    "" # Optional arguments
+    "" # Single value arguments
+    "HDRS;DEPENDS;FLAGS" # Multi-value arguments
     ${ARGN}
   )
 
   if(NOT ADD_HEADER_HDRS)
     message(FATAL_ERROR "'add_header_library' target requires a HDRS list of .h files.")
   endif()
 
-  get_fq_target_name(${target_name} fq_target_name)
-
   set(FULL_HDR_PATHS "")
   # TODO: Remove this foreach block when we can switch to the new
   # version of the CMake policy CMP0076.
   foreach(hdr IN LISTS ADD_HEADER_HDRS)
     list(APPEND FULL_HDR_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/${hdr})
   endforeach()
 
+  if(SHOW_INTERMEDIATE_OBJECTS)
+    message(STATUS "Adding header library ${fq_target_name}")
+    if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
+      foreach(dep IN LISTS ADD_HEADER_DEPENDS)
+        message(STATUS "  ${fq_target_name} depends on ${dep}")
+      endforeach()
+    endif()
+  endif()
   set(interface_target_name "${fq_target_name}.__header_library__")
 
   add_library(${interface_target_name} INTERFACE)
   target_sources(${interface_target_name} INTERFACE ${FULL_HDR_PATHS})
-  get_fq_deps_list(fq_deps_list ${ADD_HEADER_DEPENDS})
   if(ADD_HEADER_DEPENDS)
-    add_dependencies(${interface_target_name} ${fq_deps_list})
+    add_dependencies(${interface_target_name} ${ADD_HEADER_DEPENDS})
   endif()
+  set_target_properties(
+    ${interface_target_name}
+    PROPERTIES
+      INTERFACE_FLAGS "${ADD_HEADER_FLAGS}"
+  )
 
   add_custom_target(${fq_target_name})
   add_dependencies(${fq_target_name} ${interface_target_name})
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
-      "TARGET_TYPE" "${HDR_LIBRARY_TARGET_TYPE}"
-      "DEPS" "${fq_deps_list}"
+      TARGET_TYPE "${HDR_LIBRARY_TARGET_TYPE}"
+      DEPS "${ADD_HEADER_DEPENDS}"
+      FLAGS "${ADD_HEADER_FLAGS}"
+  )
+endfunction(create_header_library)
+
+# Rule to add header only libraries.
+# Usage
+#    add_header_library(
+#      <target name>
+#      HDRS  <list of .h files part of the library>
+#      DEPENDS <list of dependencies>
+#      FLAGS <list of flags>
+#    )
+
+# Internal function, used by `add_header_library`.
+function(expand_flags_for_header_library target_name flags)
+  cmake_parse_arguments(
+    "EXPAND_FLAGS"
+    "IGNORE_MARKER" # Optional arguments
+    "" # Single-value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  list(LENGTH flags nflags)
+  if(NOT ${nflags})
+    create_header_library(
+      ${target_name}
+      DEPENDS ${EXPAND_FLAGS_DEPENDS}
+      FLAGS ${EXPAND_FLAGS_FLAGS}
+      ${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
+    )
+    return()
+  endif()
+
+  list(POP_FRONT flags flag)
+  extract_flag_modifier(${flag} real_flag modifier)
+
+  if(NOT "${modifier}" STREQUAL "NO")
+    expand_flags_for_header_library(
+      ${target_name}
+      "${flags}"
+      DEPENDS ${EXPAND_FLAGS_DEPENDS} IGNORE_MARKER
+      FLAGS ${EXPAND_FLAGS_FLAGS} IGNORE_MARKER
+      ${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
+    )
+  endif()
+
+  if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
+    return()
+  endif()
+
+  set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
+  list(REMOVE_ITEM NEW_FLAGS ${flag})
+  get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
+
+  # Only target with `flag` has `.__NO_flag` target, `flag__NO` and
+  # `flag__ONLY` do not.
+  if(NOT "${modifier}")
+    set(TARGET_NAME "${target_name}.__NO_${flag}")
+  else()
+    set(TARGET_NAME "${target_name}")
+  endif()
+
+  expand_flags_for_header_library(
+    ${TARGET_NAME}
+    "${flags}"
+    DEPENDS ${NEW_DEPS} IGNORE_MARKER
+    FLAGS ${NEW_FLAGS} IGNORE_MARKER
+    ${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
+  )
+endfunction(expand_flags_for_header_library)
+
+function(add_header_library target_name)
+  cmake_parse_arguments(
+    "ADD_TO_EXPAND"
+    "" # Optional arguments
+    "" # Single value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  get_fq_target_name(${target_name} fq_target_name)
+
+  if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
+    message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
+  endif()
+
+  get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
+  get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
+  
+  list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
+  remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
+  list(SORT flags)
+
+  if(SHOW_INTERMEDIATE_OBJECTS AND flags)
+    message(STATUS "Header library ${fq_target_name} has FLAGS: ${flags}")
+  endif()
+
+  expand_flags_for_header_library(
+    ${fq_target_name}
+    "${flags}"
+    DEPENDS ${fq_deps_list} IGNORE_MARKER
+    FLAGS ${flags} IGNORE_MARKER
+    ${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
   )
 endfunction(add_header_library)

libc/cmake/modules/LLVMLibCObjectRules.cmake

 set(OBJECT_LIBRARY_TARGET_TYPE "OBJECT_LIBRARY")
 
 function(_get_common_compile_options output_var)
-  set(compile_options ${LLVM_CXX_STD_default} ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN})
+  set(compile_options ${LIBC_COMPILE_OPTIONS_DEFAULT} ${ARGN})
   if(NOT ${LIBC_TARGET_OS} STREQUAL "windows")
     set(compile_options ${compile_options} -fpie -ffreestanding)
   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-")
     list(APPEND compile_options "/GR-")
   endif()
   set(${output_var} ${compile_options} 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>
 #       COMPILE_OPTIONS <optional list of special compile options for this target>
-function(add_object_library target_name)
+#       FLAGS <optional list of flags>
+function(create_object_library fq_target_name)
   cmake_parse_arguments(
     "ADD_OBJECT"
     "" # No optional arguments
     "CXX_STANDARD" # Single value arguments
-    "SRCS;HDRS;COMPILE_OPTIONS;DEPENDS" # Multivalue arguments
+    "SRCS;HDRS;COMPILE_OPTIONS;DEPENDS;FLAGS" # Multivalue arguments
     ${ARGN}
   )
 
   if(NOT ADD_OBJECT_SRCS)
     message(FATAL_ERROR "'add_object_library' rule requires SRCS to be specified.")
   endif()
 
-  get_fq_target_name(${target_name} fq_target_name)
   add_library(
     ${fq_target_name}
     EXCLUDE_FROM_ALL
     OBJECT
     ${ADD_OBJECT_SRCS}
     ${ADD_OBJECT_HDRS}
   )
   target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_BUILD_DIR}/include
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
   )
   _get_common_compile_options(compile_options ${ADD_OBJECT_COMPILE_OPTIONS})
   target_compile_options(${fq_target_name} PRIVATE ${compile_options})
 
   get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
+
+  if(SHOW_INTERMEDIATE_OBJECTS)
+    message(STATUS "Adding object library ${fq_target_name}")
+    if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
+      foreach(dep IN LISTS ADD_OBJECT_DEPENDS)
+        message(STATUS "  ${fq_target_name} depends on ${dep}")
+      endforeach()
+    endif()
+  endif()
+
   if(fq_deps_list)
     add_dependencies(${fq_target_name} ${fq_deps_list})
   endif()
 
-  if(ADD_OBJECT_CXX_STANDARD)
-    set_target_properties(
-      ${fq_target_name}
-      PROPERTIES
-        CXX_STANDARD ${ADD_OBJECT_CXX_STANDARD}
+  if(NOT ADD_OBJECT_CXX_STANDARD)
+    set(ADD_OBJECT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+  endif()
+  
+      TARGET_TYPE ${OBJECT_LIBRARY_TARGET_TYPE}
+      OBJECT_FILES "$<TARGET_OBJECTS:${fq_target_name}>"
+      DEPS "${fq_deps_list}"
+      FLAGS "${ADD_OBJECT_FLAGS}"
+  )
+endfunction(create_object_library)
+
+# Internal function, used by `add_object_library`.
+function(expand_flags_for_object_library target_name flags)
+  cmake_parse_arguments(
+    "EXPAND_FLAGS"
+    "IGNORE_MARKER" # Optional arguments
+    "" # Single-value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  list(LENGTH flags nflags)
+  if(NOT ${nflags})
+    create_object_library(
+      ${target_name}
+      DEPENDS ${EXPAND_FLAGS_DEPENDS}
+      FLAGS ${EXPAND_FLAGS_FLAGS}
+      ${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
     )
+    return()
   endif()
 
-  set_target_properties(
+  list(POP_FRONT flags flag)
+  extract_flag_modifier(${flag} real_flag modifier)
+
+  if(NOT "${modifier}" STREQUAL "NO")
+    expand_flags_for_object_library(
+      ${target_name}
+      "${flags}"
+      DEPENDS "${EXPAND_FLAGS_DEPENDS}" IGNORE_MARKER
+      FLAGS "${EXPAND_FLAGS_FLAGS}" IGNORE_MARKER
+      "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
+    return()
+  endif()
+
+  set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
+  list(REMOVE_ITEM NEW_FLAGS ${flag})
+  get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
+
+  # Only target with `flag` has `.__NO_flag` target, `flag__NO` and
+  # `flag__ONLY` do not.
+  if(NOT "${modifier}")
+    set(TARGET_NAME "${target_name}.__NO_${flag}")
+  else()
+    set(TARGET_NAME "${target_name}")
+  endif()
+
+  expand_flags_for_object_library(
+    ${TARGET_NAME}
+    "${flags}"
+    DEPENDS "${NEW_DEPS}" IGNORE_MARKER
+    FLAGS "${NEW_FLAGS}" IGNORE_MARKER
+    "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+  )
+endfunction(expand_flags_for_object_library)
+
+function(add_object_library target_name)
+  cmake_parse_arguments(
+    "ADD_TO_EXPAND"
+    "" # Optional arguments
+    "" # Single value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  get_fq_target_name(${target_name} fq_target_name)
+
+  if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
+    message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
+  endif()
+
+  get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
+  get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
+
+  list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
+  remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
+  list(SORT flags)
+
+  if(SHOW_INTERMEDIATE_OBJECTS AND flags)
+    message(STATUS "Object library ${fq_target_name} has FLAGS: ${flags}")
+  endif()
+
+  expand_flags_for_object_library(
     ${fq_target_name}
-    PROPERTIES
-      "TARGET_TYPE" ${OBJECT_LIBRARY_TARGET_TYPE}
-      "OBJECT_FILES" "$<TARGET_OBJECTS:${fq_target_name}>"
-      "DEPS" "${fq_deps_list}"
+    "${flags}"
+    DEPENDS "${fq_deps_list}" IGNORE_MARKER
+    FLAGS "${flags}" IGNORE_MARKER
+    ${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
   )
 endfunction(add_object_library)
 
 set(ENTRYPOINT_OBJ_TARGET_TYPE "ENTRYPOINT_OBJ")
 
 # A rule for entrypoint object targets.
 # Usage:
 #     add_entrypoint_object(
 #       <target_name>
 #       [ALIAS|REDIRECTED] # Specified if the entrypoint is redirected or an alias.
 #       [NAME] <the C name of the entrypoint if different from target_name>
 #       SRCS <list of .cpp files>
 #       HDRS <list of .h files>
 #       DEPENDS <list of dependencies>
 #       COMPILE_OPTIONS <optional list of special compile options for this target>
 #       SPECIAL_OBJECTS <optional list of special object targets added by the rule `add_object`>
+#       FLAGS <optional list of flags>
 #     )
-function(add_entrypoint_object target_name)
+function(create_entrypoint_object fq_target_name)
   cmake_parse_arguments(
     "ADD_ENTRYPOINT_OBJ"
     "ALIAS;REDIRECTED" # Optional argument
     "NAME;CXX_STANDARD" # Single value arguments
-    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS"  # Multi value arguments
+    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;FLAGS"  # Multi value arguments
     ${ARGN}
   )
 
-  get_fq_target_name(${target_name} fq_target_name)
-  set(entrypoint_name ${target_name})
-  if(ADD_ENTRYPOINT_OBJ_NAME)
-    set(entrypoint_name ${ADD_ENTRYPOINT_OBJ_NAME})
-  endif()
-
-  list(FIND TARGET_ENTRYPOINT_NAME_LIST ${entrypoint_name} entrypoint_name_index)
+  list(FIND TARGET_ENTRYPOINT_NAME_LIST ${ADD_ENTRYPOINT_OBJ_NAME} entrypoint_name_index)
   if(${entrypoint_name_index} EQUAL -1)
     add_custom_target(${fq_target_name})
     set_target_properties(
       ${fq_target_name}
       PROPERTIES
-        "ENTRYPOINT_NAME" ${entrypoint_name}
+        "ENTRYPOINT_NAME" ${ADD_ENTRYPOINT_OBJ_NAME}
         "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
         "OBJECT_FILE" ""
         "OBJECT_FILE_RAW" ""
         "DEPS" ""
         "SKIPPED" "YES"
     )
     message(STATUS "Skipping libc entrypoint ${fq_target_name}.")
     return()
   endif()
 
   if(ADD_ENTRYPOINT_OBJ_ALIAS)
     # Alias targets help one add aliases to other entrypoint object targets.
     # One can use alias targets setup OS/machine independent entrypoint targets.
     list(LENGTH ADD_ENTRYPOINT_OBJ_DEPENDS deps_size)
     if(NOT (${deps_size} EQUAL "1"))
       message(FATAL_ERROR "An entrypoint alias should have exactly one dependency.")
     endif()
     list(GET ADD_ENTRYPOINT_OBJ_DEPENDS 0 dep_target)
     get_fq_dep_name(fq_dep_name ${dep_target})
+
+    if(SHOW_INTERMEDIATE_OBJECTS)
+      message(STATUS "Adding entrypoint object ${fq_target_name} as an alias of"
+              " ${fq_dep_name}")
+    endif()
+
     if(NOT TARGET ${fq_dep_name})
       message(WARNING "Aliasee ${fq_dep_name} for entrypoint alias ${target_name} missing; "
                       "Target ${target_name} will be ignored.")
       return()
     endif()
 
     get_target_property(obj_type ${fq_dep_name} "TARGET_TYPE")
     if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})))
       message(FATAL_ERROR "The aliasee of an entrypoint alias should be an entrypoint.")
     endif()
 
     add_custom_target(${fq_target_name})
     add_dependencies(${fq_target_name} ${fq_dep_name})
     get_target_property(object_file ${fq_dep_name} "OBJECT_FILE")
     get_target_property(object_file_raw ${fq_dep_name} "OBJECT_FILE_RAW")
     set_target_properties(
       ${fq_target_name}
       PROPERTIES
-        "ENTRYPOINT_NAME" ${entrypoint_name}
-        "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
-        "IS_ALIAS" "YES"
-        "OBJECT_FILE" ""
-        "OBJECT_FILE_RAW" ""
-        "DEPS" "${fq_dep_name}"
+        ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
+        TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
+        IS_ALIAS "YES"
+        OBJECT_FILE ""
+        OBJECT_FILE_RAW ""
+        DEPS "${fq_dep_name}"
+        FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
     )
     return()
   endif()
 
   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()
+  if(NOT ADD_ENTRYPOINT_OBJ_CXX_STANDARD)
+    set(ADD_ENTRYPOINT_OBJ_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+  endif()
 
   _get_common_compile_options(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)
 
+  if(SHOW_INTERMEDIATE_OBJECTS)
+    message(STATUS "Adding entrypoint object ${fq_target_name}")
+    if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
+      foreach(dep IN LISTS ADD_OBJECT_DEPENDS)
+        message(STATUS "  ${fq_target_name} depends on ${dep}")
+      endforeach()
+    endif()
+  endif()
+
   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_include_directories(${internal_target_name} PRIVATE ${include_dirs})
   add_dependencies(${internal_target_name} ${full_deps_list})
+  set_target_properties(
+    ${internal_target_name}
+    PROPERTIES
+      CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
+      FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
+  )
 
   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_include_directories(${fq_target_name} PRIVATE ${include_dirs})
   add_dependencies(${fq_target_name} ${full_deps_list})
 
-  if(ADD_ENTRYPOINT_OBJ_CXX_STANDARD)
-    set_target_properties(
-      ${fq_target_name} ${internal_target_name}
-      PROPERTIES
-        CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
-    )
-  endif()
-
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
-      "ENTRYPOINT_NAME" ${entrypoint_name}
-      "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
-      "OBJECT_FILE" $<TARGET_OBJECTS:${fq_target_name}>
+      ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
+      TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
+      OBJECT_FILE "$<TARGET_OBJECTS:${fq_target_name}>"
       # TODO: We don't need to list internal object files if the internal
       # target is a normal static library.
-      "OBJECT_FILE_RAW" $<TARGET_OBJECTS:${internal_target_name}>
-      "DEPS" "${fq_deps_list}"
+      OBJECT_FILE_RAW "$<TARGET_OBJECTS:${internal_target_name}>"
+      CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
+      DEPS "${fq_deps_list}"
+      FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
   )
 
   if(LLVM_LIBC_ENABLE_LINTING)
     if(NOT LLVM_LIBC_CLANG_TIDY)
       message(FATAL_ERROR "Something is wrong!  LLVM_LIBC_ENABLE_LINTING is "
               "ON but LLVM_LIBC_CLANG_TIDY is not set.")
     endif()
 
add_custom_command(
       # crossplatform touch.
       COMMAND "${CMAKE_COMMAND}" -E touch ${lint_timestamp}
       COMMENT "Linting... ${target_name}"
       DEPENDS clang-tidy ${internal_target_name} ${ADD_ENTRYPOINT_OBJ_SRCS}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
     )
   endif()
 
+endfunction(create_entrypoint_object)
+
+# Internal function, used by `add_entrypoint_object`.
+function(expand_flags_for_entrypoint_object target_name flags)
+  cmake_parse_arguments(
+    "EXPAND_FLAGS"
+    "IGNORE_MARKER" # Optional arguments
+    "" # Single-value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  list(LENGTH flags nflags)
+  if(NOT ${nflags})
+    create_entrypoint_object(
+      ${target_name}
+      DEPENDS ${EXPAND_FLAGS_DEPENDS}
+      FLAGS ${EXPAND_FLAGS_FLAGS}
+      ${EXPAND_FLAGS_UNPARSED_ARGUMENTS}
+    )
+    return()
+  endif()
+
+  list(POP_FRONT flags flag)
+  extract_flag_modifier(${flag} real_flag modifier)
+
+  if(NOT "${modifier}" STREQUAL "NO")
+    expand_flags_for_entrypoint_object(
+      ${target_name}
+      "${flags}"
+      DEPENDS "${EXPAND_FLAGS_DEPENDS}" IGNORE_MARKER
+      FLAGS "${EXPAND_FLAGS_FLAGS}" IGNORE_MARKER
+      "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
+    return()
+  endif()
+
+  set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
+  list(REMOVE_ITEM NEW_FLAGS ${flag})
+  get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
+
+  # Only target with `flag` has `.__NO_flag` target, `flag__NO` and
+  # `flag__ONLY` do not.
+  if(NOT "${modifier}")
+    set(TARGET_NAME "${target_name}.__NO_${flag}")
+  else()
+    set(TARGET_NAME "${target_name}")
+  endif()
+
+  expand_flags_for_entrypoint_object(
+    ${TARGET_NAME}
+    "${flags}"
+    DEPENDS "${NEW_DEPS}" IGNORE_MARKER
+    FLAGS "${NEW_FLAGS}" IGNORE_MARKER
+    "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+  )
+endfunction(expand_flags_for_entrypoint_object)
+
+function(add_entrypoint_object target_name)
+  cmake_parse_arguments(
+    "ADD_TO_EXPAND"
+    "" # Optional arguments
+    "NAME" # Single value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  get_fq_target_name(${target_name} fq_target_name)
+
+  if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
+    message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
+  endif()
+
+  get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
+  get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
+
+  list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
+  remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
+  list(SORT flags)
+
+  if(SHOW_INTERMEDIATE_OBJECTS AND flags)
+    message(STATUS "Object library ${fq_target_name} has FLAGS: ${flags}")
+  endif()
+
+  if(NOT ADD_TO_EXPAND_NAME)
+    set(ADD_TO_EXPAND_NAME ${target_name})
+  endif()
+
+  expand_flags_for_entrypoint_object(
+    ${fq_target_name}
+    "${flags}"
+    NAME ${ADD_TO_EXPAND_NAME} IGNORE_MARKER
+    DEPENDS "${fq_deps_list}" IGNORE_MARKER
+    FLAGS "${flags}" IGNORE_MARKER
+    ${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
+  )
 endfunction(add_entrypoint_object)
 
 set(ENTRYPOINT_EXT_TARGET_TYPE "ENTRYPOINT_EXT")
 
 # A rule for external entrypoint targets.
 # Usage:
 #     add_entrypoint_external(
 #       <target_name>

libc/cmake/modules/LLVMLibCRules.cmake

 include(LLVMLibCTargetNameUtils)
+include(LLVMLibCFlagRules)
 include(LLVMLibCHeaderRules)
 include(LLVMLibCObjectRules)
 include(LLVMLibCLibraryRules)
 include(LLVMLibCTestRules)

libc/cmake/modules/LLVMLibCTestRules.cmake

 #      <target name>
 #      SUITE <name of the suite this test belongs to>
 #      SRCS  <list of .cpp files for the test>
 #      HDRS  <list of .h files for the test>
 #      DEPENDS <list of dependencies>
 #      COMPILE_OPTIONS <list of special compile options for this target>
 #      LINK_LIBRARIES <list of linking libraries for this target>
 #    )
-function(add_libc_unittest target_name)
+function(create_libc_unittest fq_target_name)
   if(NOT LLVM_INCLUDE_TESTS)
     return()
   endif()
 
   cmake_parse_arguments(
     "LIBC_UNITTEST"
     "NO_RUN_POSTBUILD;NO_LIBC_UNITTEST_TEST_MAIN" # Optional arguments
     "SUITE;CXX_STANDARD" # Single value arguments
-    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;LINK_LIBRARIES" # Multi-value arguments
+    "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;LINK_LIBRARIES;FLAGS" # Multi-value arguments
     ${ARGN}
   )
   if(NOT LIBC_UNITTEST_SRCS)
     message(FATAL_ERROR "'add_libc_unittest' target requires a SRCS list of .cpp "
                         "files.")
   endif()
   if(NOT LIBC_UNITTEST_DEPENDS)
     message(FATAL_ERROR "'add_libc_unittest' target requires a DEPENDS list of "
                         "'add_entrypoint_object' targets.")
   endif()
 
-  get_fq_target_name(${target_name} fq_target_name)
   get_fq_deps_list(fq_deps_list ${LIBC_UNITTEST_DEPENDS})
   get_object_files_for_test(
       link_object_files skipped_entrypoints_list ${fq_deps_list})
   if(skipped_entrypoints_list)
     # If a test is OS/target machine independent, it has to be skipped if the
     # OS/target machine combination does not provide any dependent entrypoints.
     # If a test is OS/target machine specific, then such a test will live is a
     # OS/target machine specific directory and will be skipped at the directory
if(skipped_entrypoints_list)
     # is happening here at the entrypoint level.
 
     set(msg "Skipping unittest ${fq_target_name} as it has missing deps: "
             "${skipped_entrypoints_list}.")
     message(STATUS ${msg})
     return()
   endif()
 
+  if(SHOW_INTERMEDIATE_OBJECTS)
+    message(STATUS "Adding unit test ${fq_target_name}")
+    if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
+      foreach(dep IN LISTS ADD_OBJECT_DEPENDS)
+        message(STATUS "  ${fq_target_name} depends on ${dep}")
+      endforeach()
+    endif()
+  endif()
+
   add_executable(
     ${fq_target_name}
     EXCLUDE_FROM_ALL
     ${LIBC_UNITTEST_SRCS}
     ${LIBC_UNITTEST_HDRS}
   )
   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()
-  if(LIBC_UNITTEST_CXX_STANDARD)
-    set_target_properties(
-      ${fq_target_name}
-      PROPERTIES
-        CXX_STANDARD ${LIBC_UNITTEST_CXX_STANDARD}
-    )
-  endif()
+  if(NOT LIBC_UNITTEST_CXX_STANDARD)
+    set(LIBC_UNITTEST_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+  endif()
 
   # Test object files will depend on LINK_LIBRARIES passed down from `add_fp_unittest`
   set(link_libraries ${link_object_files} ${LIBC_UNITTEST_LINK_LIBRARIES})
 
   set_target_properties(${fq_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
function(create_libc_unittest fq_target_name)
   endif()
 
   if(LIBC_UNITTEST_SUITE)
     add_dependencies(
       ${LIBC_UNITTEST_SUITE}
       ${fq_target_name}
     )
   endif()
+endfunction(create_libc_unittest)
+
+# Internal function, used by `add_libc_unittest`.
+function(expand_flags_for_libc_unittest target_name flags)
+  cmake_parse_arguments(
+    "EXPAND_FLAGS"
+    "IGNORE_MARKER" # No Optional arguments
+    "" # No Single-value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  list(LENGTH flags nflags)
+  if(NOT ${nflags})
+    create_libc_unittest(
+      ${target_name}
+      DEPENDS "${EXPAND_FLAGS_DEPENDS}"
+      FLAGS "${EXPAND_FLAGS_FLAGS}"
+      "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+    )
+    return()
+  endif()
+
+  list(POP_FRONT flags flag)
+  extract_flag_modifier(${flag} real_flag modifier)
+
+  if(NOT "${modifier}" STREQUAL "NO")
+    expand_flags_for_libc_unittest(
+      ${target_name}
+      "${flags}"
+      DEPENDS "${EXPAND_FLAGS_DEPENDS}" IGNORE_MARKER
+      FLAGS "${EXPAND_FLAGS_FLAGS}" IGNORE_MARKER
+      "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+    )
+  endif()
+
+  if("${real_flag}" STREQUAL "" OR "${modifier}" STREQUAL "ONLY")
+    return()
+  endif()
+
+  set(NEW_FLAGS ${EXPAND_FLAGS_FLAGS})
+  list(REMOVE_ITEM NEW_FLAGS ${flag})
+  get_fq_dep_list_without_flag(NEW_DEPS ${real_flag} ${EXPAND_FLAGS_DEPENDS})
+
+  # Only target with `flag` has `.__NO_flag` target, `flag__NO` and
+  # `flag__ONLY` do not.
+  if(NOT "${modifier}")
+    set(TARGET_NAME "${target_name}.__NO_${flag}")
+  else()
+    set(TARGET_NAME "${target_name}")
+  endif()
+
+  expand_flags_for_libc_unittest(
+    ${TARGET_NAME}
+    "${flags}"
+    DEPENDS "${NEW_DEPS}" IGNORE_MARKER
+    FLAGS "${NEW_FLAGS}" IGNORE_MARKER
+    "${EXPAND_FLAGS_UNPARSED_ARGUMENTS}"
+  )
+endfunction(expand_flags_for_libc_unittest)
+
+function(add_libc_unittest target_name)
+  cmake_parse_arguments(
+    "ADD_TO_EXPAND"
+    "" # Optional arguments
+    "" # Single value arguments
+    "DEPENDS;FLAGS" # Multi-value arguments
+    ${ARGN}
+  )
+
+  get_fq_target_name(${target_name} fq_target_name)
+
+  if(ADD_TO_EXPAND_DEPENDS AND ("${SHOW_INTERMEDIATE_OBJECTS}" STREQUAL "DEPS"))
+    message(STATUS "Gathering FLAGS from dependencies for ${fq_target_name}")
+  endif()
+
+  get_fq_deps_list(fq_deps_list ${ADD_TO_EXPAND_DEPENDS})
+  get_flags_from_dep_list(deps_flag_list ${fq_deps_list})
+  
+  list(APPEND ADD_TO_EXPAND_FLAGS ${deps_flag_list})
+  remove_duplicated_flags("${ADD_TO_EXPAND_FLAGS}" flags)
+  list(SORT flags)
+
+  if(SHOW_INTERMEDIATE_OBJECTS AND flags)
+    message(STATUS "Unit test ${fq_target_name} has FLAGS: ${flags}")
+  endif()
+
+  expand_flags_for_libc_unittest(
+    ${fq_target_name}
+    "${flags}"
+    DEPENDS ${fq_deps_list} IGNORE_MARKER
+    FLAGS ${flags} IGNORE_MARKER
+    ${ADD_TO_EXPAND_UNPARSED_ARGUMENTS}
+  )
 endfunction(add_libc_unittest)
 
 function(add_libc_testsuite suite_name)
   add_custom_target(${suite_name})
   add_dependencies(check-llvmlibc ${suite_name})
 endfunction(add_libc_testsuite)
 
 function(add_libc_exhaustive_testsuite suite_name)

libc/test/src/CMakeLists.txt

function(add_fp_unittest name)
 
   if(MATH_UNITTEST_NEED_MPFR)
     list(APPEND MATH_UNITTEST_LINK_LIBRARIES libcMPFRWrapper -lmpfr -lgmp)
   endif()
   list(APPEND MATH_UNITTEST_LINK_LIBRARIES LibcFPTestHelpers)
 
   add_libc_unittest(
     ${name}
-    "${MATH_UNITTEST_UNPARSED_ARGUMENTS}"
     LINK_LIBRARIES "${MATH_UNITTEST_LINK_LIBRARIES}"
+    "${MATH_UNITTEST_UNPARSED_ARGUMENTS}"
   )
 endfunction(add_fp_unittest)
 
 add_subdirectory(__support)
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(fenv)
 add_subdirectory(inttypes)

libc/test/src/__support/File/CMakeLists.txt

 if(NOT (TARGET libc.src.__support.threads.mutex))
   # Not all platforms have a mutex implementation. If mutex is unvailable,
   # we just skip everything about files.
   return()
 endif()
 
 add_libc_unittest(
   file_test
   SUITE
     libc_support_unittests
   SRCS
     file_test.cpp
+  LINK_LIBRARIES
+    LibcMemoryHelpers
   DEPENDS
     libc.include.errno
     libc.include.stdio
     libc.include.stdlib
     libc.src.__support.File.file
-  LINK_LIBRARIES
-    LibcMemoryHelpers
 )
 
 if (TARGET libc.src.__support.File.platform_file)
   add_libc_unittest(
     platform_file_test
     SUITE
       libc_support_unittests
     SRCS

libc/test/src/__support/OSUtil/linux/x86_64/CMakeLists.txt

 add_libc_unittest(
   syscall_unittest
   SUITE libc_osutil_tests
   SRCS syscall_test.cpp
-  DEPENDS
-    libc.src.__support.OSUtil.osutil
   COMPILE_OPTIONS
     -Wno-unused-variable # Only signature tests, declared variables are unused.
+  DEPENDS
+    libc.src.__support.OSUtil.osutil
 )

libc/test/src/math/exhaustive/CMakeLists.txt

 add_fp_unittest(
   hypotf_test
   NO_RUN_POSTBUILD
   NEED_MPFR
   SUITE
     libc_math_exhaustive_tests
   SRCS
     hypotf_test.cpp
+  COMPILE_OPTIONS
+    -O3
   DEPENDS
     .exhaustive_test
     libc.include.math
     libc.src.math.hypotf
     libc.src.__support.FPUtil.fputil
-  COMPILE_OPTIONS
-    -O3
   LINK_LIBRARIES
     -lpthread
 )

libc/test/src/stdio/printf_core/CMakeLists.txt

 add_libc_unittest(
   parser_test
   SUITE
     libc_stdio_unittests
   SRCS
     parser_test.cpp
+  LINK_LIBRARIES
+    LibcPrintfHelpers
   DEPENDS
     libc.src.stdio.printf_core.parser
     libc.src.stdio.printf_core.core_structs
     libc.src.__support.arg_list
-  LINK_LIBRARIES
-    LibcPrintfHelpers
 )
 
 add_libc_unittest(
   string_writer_test
   SUITE
     libc_stdio_unittests
   SRCS
     string_writer_test.cpp

libc/test/src/string/CMakeLists.txt

function(add_libc_multi_impl_test name)
   foreach(fq_config_name IN LISTS fq_implementations)
     get_target_property(required_cpu_features ${fq_config_name} REQUIRE_CPU_FEATURES)
     cpu_supports(can_run "${required_cpu_features}")
     if(can_run)
       add_libc_unittest(
         ${fq_config_name}_test
         SUITE
           libc_string_unittests
-        DEPENDS
-          ${fq_config_name}
         COMPILE_OPTIONS
           ${LIBC_COMPILE_OPTIONS_NATIVE}
         LINK_LIBRARIES
           LibcMemoryHelpers
         ${ARGN}
+        DEPENDS
+          ${fq_config_name}
       )
       get_fq_target_name(${fq_config_name}_test fq_target_name)
     else()
       message(STATUS "Skipping test for '${fq_config_name}' insufficient host cpu features '${required_cpu_features}'")
     endif()
   endforeach()
 endfunction()
 
 add_libc_multi_impl_test(bcmp SRCS bcmp_test.cpp)
 add_libc_multi_impl_test(bzero SRCS bzero_test.cpp)
 add_libc_multi_impl_test(memcmp SRCS memcmp_test.cpp)
 add_libc_multi_impl_test(memcpy SRCS memcpy_test.cpp)
 add_libc_multi_impl_test(memmove SRCS memmove_test.cpp)
 add_libc_multi_impl_test(memset SRCS memset_test.cpp)

libc/test/src/string/memory_utils/CMakeLists.txt

 add_libc_unittest(
   utils_test
   SUITE
     libc_string_unittests
   SRCS
     elements_test.cpp
     memory_access_test.cpp
     utils_test.cpp
+  COMPILE_OPTIONS
+    ${LIBC_COMPILE_OPTIONS_NATIVE}
+    -ffreestanding
   DEPENDS
     libc.src.string.memory_utils.memory_utils
     libc.src.__support.CPP.array
     libc.src.__support.CPP.array_ref
-  COMPILE_OPTIONS
-    ${LIBC_COMPILE_OPTIONS_NATIVE}
-    -ffreestanding
 )