[libc] Skip entrypoints not present in the entrypoints list.

[sivachandra]

Summary

If a test depends on a skipped entrypoint, then the test is also
skipped. This setup will be useful as we add gradually add support for
more operating systems and target architectures.

[asteinhauser]

Nice.

libc/cmake/modules/LLVMLibCTestRules.cmake

104

Typo: machince instead of machine

libc/CMakeLists.txt

 endif()
 
 include(CMakeParseArguments)
 include(LLVMLibCRules)
 include(LLVMLibCCheckCpuFeatures)
 
 add_subdirectory(include)
 add_subdirectory(config)
+
+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/entrypoints.txt")
+include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/headers.txt")
+
+set(TARGET_ENTRYPOINT_NAME_LIST "")
+foreach(entrypoint IN LISTS TARGET_LIBC_ENTRYPOINTS TARGET_LIBM_ENTRYPOINTS)
+  string(FIND ${entrypoint} "." last_dot_loc REVERSE)
+  if(${last_dot_loc} EQUAL -1)
+    message(FATAL "Invalid entrypoint target name ${entrypoint}; Expected a '.' "
+                  "(dot) in the name.")
+  endif()
+  math(EXPR name_loc "${last_dot_loc} + 1")
+  string(SUBSTRING ${entrypoint} ${name_loc} -1 entrypoint_name)
+  list(APPEND TARGET_ENTRYPOINT_NAME_LIST ${entrypoint_name})
+endforeach()
+
 add_subdirectory(src)
 add_subdirectory(utils)
 
 # The loader can potentially depend on the library components so add it
 # after the library implementation directories.
 add_subdirectory(loader)
 
 # 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()

libc/cmake/modules/LLVMLibCObjectRules.cmake

function(add_entrypoint_object target_name)
   )
 
   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)
+  if(${entrypoint_name_index} EQUAL -1)
+    add_custom_target(${fq_target_name})
+    set_target_properties(
+      ${fq_target_name}
+      PROPERTIES
+        "ENTRYPOINT_NAME" ${entrypoint_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)

libc/cmake/modules/LLVMLibCTestRules.cmake

 # This is a helper function and not a build rule. It is to be used by the
 # various test rules to generate the full list of object files
 # recursively produced by "add_entrypoint_object" and "add_object_library"
 # targets.
 # Usage:
-#   get_object_files_for_test(<result var> <target0> [<target1> ...])
+#   get_object_files_for_test(<result var>
+#                             <skipped_entrypoints_var>
+#                             <target0> [<target1> ...])
 #
+#   The list of object files is collected in <result_var>.
+#   If skipped entrypoints were found, then <skipped_entrypoints_var> is
+#   set to a true value.
 #   targetN is either an "add_entrypoint_target" target or an
 #   "add_object_library" target.
-function(get_object_files_for_test result)
+function(get_object_files_for_test result skipped_entrypoints_list)
   set(object_files "")
+  set(skipped_list "")
   foreach(dep IN LISTS ARGN)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
     if(NOT dep_type)
       # Target for which TARGET_TYPE property is not set do not
       # provide any object files.
       continue()
     endif()
 
     if(${dep_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})
       get_target_property(dep_object_files ${dep} "OBJECT_FILES")
       if(dep_object_files)
         list(APPEND object_files ${dep_object_files})
       endif()
     elseif(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})
+      get_target_property(is_skipped ${dep} "SKIPPED")
+      if(is_skipped)
+        list(APPEND skipped_list ${dep})
+        continue()
+      endif()
       get_target_property(object_file_raw ${dep} "OBJECT_FILE_RAW")
       if(object_file_raw)
         list(APPEND object_files ${object_file_raw})
       endif()
     endif()
 
     get_target_property(indirect_deps ${dep} "DEPS")
-    get_object_files_for_test(indirect_objfiles ${indirect_deps})
+    get_object_files_for_test(
+        indirect_objfiles indirect_skipped_list ${indirect_deps})
     list(APPEND object_files ${indirect_objfiles})
+    if(indirect_skipped_list)
+      list(APPEND skipped_list ${indirect_skipped_list})
+    endif()
   endforeach(dep)
   list(REMOVE_DUPLICATES object_files)
   set(${result} ${object_files} PARENT_SCOPE)
+  list(REMOVE_DUPLICATES skipped_list)
+  set(${skipped_entrypoints_list} ${skipped_list} PARENT_SCOPE)
 endfunction(get_object_files_for_test)
 
 # Rule to add a libc unittest.
 # Usage
 #    add_libc_unittest(
 #      <target name>
 #      SUITE <name of the suite this test belongs to>
 #      SRCS  <list of .cpp files for the test>
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
+    # level if required.
+    #
+    # There can potentially be a setup like this: A unittest is setup for a
+    # OS/target machine independent object library, which in turn depends on a
+    # machine specific object library. Such a test would be testing internals of
+    # the libc and it is assumed that they will be rare in practice. So, they
+    # can be skipped in the corresponding CMake files using platform specific
+    # logic. This pattern is followed in the loader tests for example.
+    #
+    # Another pattern that is present currently is to detect machine
+    # capabilities and add entrypoints and tests accordingly. That approach is
+    # much lower level approach and is independent of the kind of skipping that
+    # 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})
+    add_custom_target(${fq_target_name})
+
+    # A post build custom command is used to avoid running the command always.
+    add_custom_command(
+      TARGET ${fq_target_name}
+      POST_BUILD
+      COMMAND ${CMAKE_COMMAND} -E echo ${msg}
+    )
+    return()
+  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
   )
   if(LIBC_UNITTEST_COMPILE_OPTIONS)
     target_compile_options(
       ${target_name}
       PRIVATE ${LIBC_UNITTEST_COMPILE_OPTIONS}
     )
   endif()
 
-  get_fq_deps_list(fq_deps_list ${LIBC_UNITTEST_DEPENDS})
-  get_object_files_for_test(link_object_files ${fq_deps_list})
   target_link_libraries(${fq_target_name} PRIVATE ${link_object_files})
 
   set_target_properties(${fq_target_name}
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
     ${fq_target_name}
     ${fq_deps_list}

libc/config/linux/x86_64/entrypoints.txt

-set(LIBC_ENTRYPOINTS
+set(TARGET_LIBC_ENTRYPOINTS
     # assert.h entrypoints
     libc.src.assert.__assert_fail
 
     # errno.h entrypoints
     libc.src.errno.__errno_location
 
     # signal.h entrypoints
     libc.src.signal.raise
set(TARGET_LIBC_ENTRYPOINTS
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
 
     # unistd.h entrypoints
     libc.src.unistd.write
 )
 
-set(LIBM_ENTRYPOINTS
+set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.cosf
     libc.src.math.expf
     libc.src.math.exp2f
     libc.src.math.fabs
     libc.src.math.fabsf
     libc.src.math.floor
     libc.src.math.floorf
     libc.src.math.round
     libc.src.math.sincosf
     libc.src.math.sinf
     libc.src.math.trunc
     libc.src.math.truncf
 )

libc/config/linux/x86_64/headers.txt

-set(PUBLIC_HEADERS
+set(TARGET_PUBLIC_HEADERS
     libc.include.assert_h
     libc.include.errno
     libc.include.math
     libc.include.signal
     libc.include.stdio
     libc.include.stdlib
     libc.include.sys_mman
     libc.include.sys_syscall
     libc.include.threads
     libc.include.unistd
 )

libc/lib/CMakeLists.txt

-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/entrypoints.txt")
-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/headers.txt")
-
 add_entrypoint_library(
   llvmlibc
   DEPENDS
-  ${LIBC_ENTRYPOINTS}
+  ${TARGET_LIBC_ENTRYPOINTS}
 )
 
 add_entrypoint_library(
   llvmlibm
   DEPENDS
-  ${LIBM_ENTRYPOINTS}
+  ${TARGET_LIBM_ENTRYPOINTS}
 )
 
 add_redirector_library(
   llvmlibc_redirectors
   DEPENDS
     round_redirector
 )

libc/loader/linux/CMakeLists.txt

set_target_properties(
     ${fq_target_name}
     PROPERTIES
       "TARGET_TYPE" "${OBJECT_LIBRARY_TARGET_TYPE}"
       "OBJECT_FILES" ""
       "DEPS" "${fq_target_name}.__objects__"
   )
 endfunction()
 
+if(NOT (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_MACHINE}))
+  message(STATUS "Skipping loader for target machine ${LIBC_TARGET_MACHINE}")
+  return()
+endif()
+
 add_subdirectory(${LIBC_TARGET_MACHINE})
 
 add_loader_object(
   crt1
   ALIAS
   DEPENDS
     .${LIBC_TARGET_MACHINE}.crt1
 )

libc/test/loader/CMakeLists.txt

target_include_directories(
     ${fq_target_name}
     PRIVATE
       ${LIBC_SOURCE_DIR}
       ${LIBC_BUILD_DIR}
       ${LIBC_BUILD_DIR}/include
   )
 
   get_fq_deps_list(fq_deps_list ${ADD_LOADER_TEST_DEPENDS})
-  get_object_files_for_test(link_object_files ${fq_deps_list})
+  get_object_files_for_test(link_object_files has_skipped_entrypoint_list ${fq_deps_list})
   target_link_libraries(${fq_target_name} ${link_object_files})
 
   target_link_options(
     ${fq_target_name}
     BEFORE PRIVATE
     -nostdlib
   )
 

libc/test/loader/linux/CMakeLists.txt

+if(NOT (EXISTS ${LIBC_SOURCE_DIR}/loader/linux/${LIBC_TARGET_MACHINE}))
+  message("Skipping loader tests for target machine ${LIBC_TARGET_MACHINE}.")
+  return()
+endif()
+
 add_loader_test(
   loader_args_test
   SRC
     args_test.cpp
   DEPENDS
     libc.loader.linux.crt1
     libc.src.assert.__assert_fail
     libc.src.signal.raise

libc/test/src/CMakeLists.txt

 add_subdirectory(assert)
 add_subdirectory(errno)
 add_subdirectory(math)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(string)
 add_subdirectory(sys)
 add_subdirectory(threads)
 add_subdirectory(unistd)
 
-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/entrypoints.txt")
-include("${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/${LIBC_TARGET_MACHINE}/headers.txt")
-
 set(public_test ${CMAKE_CURRENT_BINARY_DIR}/public_integration_test.cpp)
 
 set(entrypoints_name_list "")
-foreach(entry IN LISTS LIBC_ENTRYPOINTS LIBM_ENTRYPOINTS)
+foreach(entry IN LISTS TARGET_LIBC_ENTRYPOINTS TARGET_LIBM_ENTRYPOINTS)
   get_target_property(entry_name ${entry} "ENTRYPOINT_NAME")
   list(APPEND entrypoints_name_list ${entry_name})
 endforeach()
 
 # TODO: Remove these when they are added to the TableGen.
 list(REMOVE_ITEM entrypoints_name_list "__assert_fail" "__errno_location")
 list(TRANSFORM entrypoints_name_list PREPEND "-e=")