[libc] Do not run tests on vendor implemented math

[jhuber6]

Summary

We currently remap vendor implementations of math functions to provide a
temporarily functional libm.a for the GPU. However, we should not run
tests on any files that depend on these vendor implementations as they
are not under our control and are not always present.

The goal in the future is to remove the need for this by replacing all
the vendor functionality, but for now this is a workaround.

[JonChesterfield]

We might want this under user control. I can see use cases for running our math tests against vendor libs (checking the vendor lib, that we're compiling the libs correctly, checking our tests don't reflect errors in our implementation).

However I'm delighted to be able to run the tests without rocm available once more, thank you for unblocking that use case.

libc/cmake/modules/LLVMLibCLibraryRules.cmake

if(NOT ENTRYPOINT_LIBRARY_DEPENDS)
     message(FATAL_ERROR "'add_entrypoint_library' target requires a DEPENDS list "
                         "of 'add_entrypoint_object' targets.")
   endif()
 
   get_fq_deps_list(fq_deps_list ${ENTRYPOINT_LIBRARY_DEPENDS})
   set(all_deps "")
   foreach(dep IN LISTS fq_deps_list)
     get_target_property(dep_type ${dep} "TARGET_TYPE")
-    if(NOT ((${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE}) OR (${dep_type} STREQUAL ${ENTRYPOINT_EXT_TARGET_TYPE})))
+    if(NOT ((${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE}) OR
+            (${dep_type} STREQUAL ${ENTRYPOINT_EXT_TARGET_TYPE}) OR
+            (${dep_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})))
       message(FATAL_ERROR "Dependency '${dep}' of 'add_entrypoint_collection' is "
                           "not an 'add_entrypoint_object' or 'add_entrypoint_external' target.")
     endif()
     collect_object_file_deps(${dep} recursive_deps)
     list(APPEND all_deps ${recursive_deps})
     # Add the entrypoint object target explicitly as collect_object_file_deps
     # only collects object files from non-entrypoint targets.
     if(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})

libc/cmake/modules/LLVMLibCObjectRules.cmake

expand_flags_for_object_library(
     "${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")
+set(ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE "ENTRYPOINT_OBJ_VENDOR")
 
 # 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(create_entrypoint_object fq_target_name)
   cmake_parse_arguments(
     "ADD_ENTRYPOINT_OBJ"
-    "ALIAS;REDIRECTED" # Optional argument
+    "ALIAS;REDIRECTED;VENDOR" # Optional argument
     "NAME;CXX_STANDARD" # Single value arguments
     "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;FLAGS"  # Multi value arguments
     ${ARGN}
   )
 
+  set(entrypoint_target_type ${ENTRYPOINT_OBJ_TARGET_TYPE})
+  if(${ADD_ENTRYPOINT_OBJ_VENDOR})
+    # TODO: We currently rely on external definitions of certain math functions
+    # provided by GPU vendors like AMD or Nvidia. We need to mark these so we
+    # don't end up running tests on these. In the future all of these should be
+    # implemented and this can be removed.
+    set(entrypoint_target_type ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})
+  endif()
   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" ${ADD_ENTRYPOINT_OBJ_NAME}
-        "TARGET_TYPE" ${ENTRYPOINT_OBJ_TARGET_TYPE}
+        "TARGET_TYPE" ${entrypoint_target_type}
         "OBJECT_FILE" ""
         "OBJECT_FILE_RAW" ""
         "DEPS" ""
         "SKIPPED" "YES"
     )
     if(LIBC_CMAKE_VERBOSE_LOGGING)
       message(STATUS "Skipping libc entrypoint ${fq_target_name}.")
     endif()
if(ADD_ENTRYPOINT_OBJ_ALIAS)
 
     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})))
+    if((NOT obj_type) OR (NOT (${obj_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE} OR
+                               ${obj_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_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 ${ADD_ENTRYPOINT_OBJ_NAME}
-        TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
+        TARGET_TYPE ${entrypoint_target_type}
         IS_ALIAS "YES"
         OBJECT_FILE ""
         OBJECT_FILE_RAW ""
         DEPS "${fq_dep_name}"
         FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
     )
     return()
   endif()

libc/cmake/modules/LLVMLibCTestRules.cmake

elseif(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE})
       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()
+    elseif(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})
+      # We skip tests for all externally implemented entrypoints.
+      list(APPEND skipped_list ${dep})
+      continue()
     endif()
 
     get_target_property(indirect_deps ${dep} "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})

libc/src/math/CMakeLists.txt

function(add_math_entrypoint_object name)
   # entrypoints it means the user requested it and we should use it instead.
   get_fq_target_name("${LIBC_TARGET_ARCHITECTURE}.vendor.${name}" fq_vendor_specific_target_name)
   if(TARGET ${fq_vendor_specific_target_name})
     add_entrypoint_object(
       ${name}
       ALIAS
       DEPENDS
         .${LIBC_TARGET_ARCHITECTURE}.vendor.${name}
+      VENDOR
     )
     return()
   endif()
 
   get_fq_target_name("generic.${name}" fq_generic_target_name)
   if(TARGET ${fq_generic_target_name})
     add_entrypoint_object(
       ${name}

libc/src/math/gpu/CMakeLists.txt

 add_math_entrypoint_gpu_object(
   truncf
   SRCS
     truncf.cpp
   HDRS
     ../truncf.h
   COMPILE_OPTIONS
     -O2
-)
+)
 

libc/src/math/gpu/vendor/CMakeLists.txt

add_entrypoint_object(
   tanhf
   SRCS
     tanhf.cpp
   HDRS
     ../../tanhf.h
   COMPILE_OPTIONS
     ${bitcode_link_flags}
     -O2
-)
+)