[libc] Support add_object_library for the GPU build

[jhuber6]

Summary

This patch unifies the handling of generating the GPU build targets
between the add_entrypoint_library and the add_object_library
functions. The _build_gpu_objects function will create two targets.
One contains a single object file with several GPU binaries embedded in
it, a so-called fatbinary. The other is a direct compile of the
supported target to be used internally only. This patch pulls out some
of the properties logic so that we can handle both more easily. This
patch also required adding an ovverride NO_GPU_BUILD for cases when
we only want to build the source file as normal.

[jhuber6]

Changing the ENTRYPOINTS name in the CMake argument variable

[lntue]

libc/cmake/modules/LLVMLibCObjectRules.cmake

199

Look like NO_GPU_BUILD belongs to optional arguments, i.e. the line above.

[jhuber6]

Move the NO_GPU_BUILD option to the optional arguments.

[lntue]

Overall it looks good to me, but let's wait for @sivachandra to comment on the patch.

Also, I just noticed that build_gpu_objects is called after FLAGS expansion (via the chain add_entrypoint_object -> expand_flags_for_entrypoint_object -> create_entrypoint_object -> build_gpu_objects),
so for an entry point object with some FLAGS properties (that are currently used to create multiple targets for different CPU configurations, especially in math functions), redundant GPU targets will be generated.
This is probably not a problem with the current set of entry points enabled for GPU yet.

Anyway since we are going to push CMake version to 3.20 matching LLVM updated requirements, it's probably a good time for me to revise the FLAGS implementations make sure it works well with other use cases.

[sivachandra]

LGTM, but I have left a naming suggestion.

libc/startup/gpu/nvptx/CMakeLists.txt

13

The name NO_GPU_BUILD seems odd when you do have LIBC_GPU_TARGET_ARCHITECTURE. May be name it NO_GPU_BUNDLE?

libc/cmake/modules/LLVMLibCObjectRules.cmake

function(_get_common_compile_options output_var flags)
   endif()
   if (LIBC_TARGET_ARCHITECTURE_IS_GPU)
     list(APPEND compile_options "-nogpulib")
     list(APPEND compile_options "-fvisibility=hidden")
   endif()
   set(${output_var} ${compile_options} PARENT_SCOPE)
 endfunction()
 
-# Builds the entrypoint target for the GPU.
+# Builds the object target for the GPU.
+# This compiles the target for all supported architectures and embeds it into
+# host binary for installing. The internal target contains the GPU code directly
+# compiled for a single architecture used internally.
 # Usage:
-#     _build_gpu_entrypoint_objects(
+#     _build_gpu_objects(
 #       <target_name>
+#       <internal_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>
 #       FLAGS <optional list of flags>
 #     )
-function(_build_gpu_entrypoint_objects fq_target_name)
+function(_build_gpu_objects fq_target_name internal_target_name)
   cmake_parse_arguments(
-    "ADD_GPU_ENTRYPOINT_OBJ"
+    "ADD_GPU_OBJ"
     "" # No optional arguments
     "NAME;CXX_STANDARD" # Single value arguments
     "SRCS;HDRS;DEPENDS;COMPILE_OPTIONS;FLAGS"  # Multi value arguments
     ${ARGN}
   )
 
   # The packaged version will be built for every target GPU architecture. We do
   # this so we can support multiple accelerators on the same machine.
   foreach(gpu_arch ${all_gpu_architectures})
     set(gpu_target_name ${fq_target_name}.${gpu_arch})
-    set(compile_options ${ADD_GPU_ENTRYPOINT_OBJ_COMPILE_OPTIONS})
+    set(compile_options ${ADD_GPU_OBJ_COMPILE_OPTIONS})
     # Derive the triple from the specified architecture.
     if("${gpu_arch}" IN_LIST all_amdgpu_architectures)
       set(gpu_target_triple "amdgcn-amd-amdhsa")
       list(APPEND compile_options "-mcpu=${gpu_arch}")
     elseif("${gpu_arch}" IN_LIST all_nvptx_architectures)
       set(gpu_target_triple "nvptx64-nvidia-cuda")
       list(APPEND compile_options "-march=${gpu_arch}")
     else()
       message(FATAL_ERROR "Unknown GPU architecture '${gpu_arch}'")
     endif()
     list(APPEND compile_options "--target=${gpu_target_triple}")
     list(APPEND compile_options "-emit-llvm")
 
     # Build the library for this target architecture. We always emit LLVM-IR for
     # packaged GPU binaries.
     add_library(${gpu_target_name}
       EXCLUDE_FROM_ALL
       OBJECT
-      ${ADD_GPU_ENTRYPOINT_OBJ_SRCS}
-      ${ADD_GPU_ENTRYPOINT_OBJ_HDRS}
+      ${ADD_GPU_OBJ_SRCS}
+      ${ADD_GPU_OBJ_HDRS}
     )
 
     target_compile_options(${gpu_target_name} PRIVATE ${compile_options})
     target_include_directories(${gpu_target_name} PRIVATE ${include_dirs})
-    add_dependencies(${gpu_target_name} ${ADD_GPU_ENTRYPOINT_OBJ_DEPENDS})
     target_compile_definitions(${gpu_target_name} PRIVATE LIBC_COPT_PUBLIC_PACKAGING)
+    if(ADD_GPU_OBJ_DEPENDS)
+      add_dependencies(${gpu_target_name} ${ADD_GPU_OBJ_DEPENDS})
+    endif()
 
     # Append this target to a list of images to package into a single binary.
     set(input_file $<TARGET_OBJECTS:${gpu_target_name}>)
     list(APPEND packager_images
          --image=file=${input_file},arch=${gpu_arch},triple=${gpu_target_triple})
     list(APPEND gpu_target_names ${gpu_target_name})
   endforeach()
 
add_custom_command(OUTPUT ${packaged_output_name}
                      COMMENT "Packaging LLVM offloading binary")
   add_custom_target(${packaged_target_name} DEPENDS ${packaged_output_name})
 
   # We create an empty 'stub' file for the host to contain the embedded device
   # code. This will be packaged into 'libcgpu.a'.
   # TODO: In the future we will want to combine every architecture for a target
   #       into a single bitcode file and use that. For now we simply build for
   #       every single one and let the offloading linker handle it.
-  get_filename_component(stub_filename ${ADD_GPU_ENTRYPOINT_OBJ_SRCS} NAME)
+  get_filename_component(stub_filename ${ADD_GPU_OBJ_SRCS} NAME)
   file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/stubs)
   file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename} "// Empty file.\n")
   add_library(
     ${fq_target_name}
     # We want an object library as the objects will eventually get packaged into
     # an archive (like libcgpu.a).
     EXCLUDE_FROM_ALL
     OBJECT
     "${CMAKE_CURRENT_BINARY_DIR}/stubs/${stub_filename}"
   )
   target_compile_options(${fq_target_name} BEFORE PRIVATE ${common_compile_options}
                          -nostdlib -Xclang -fembed-offload-object=${packaged_output_name})
   target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
   add_dependencies(${fq_target_name} ${full_deps_list} ${packaged_target_name})
 
-  set_target_properties(
-    ${fq_target_name}
-    PROPERTIES
-      ENTRYPOINT_NAME ${ADD_ENTRYPOINT_OBJ_NAME}
-      TARGET_TYPE ${ENTRYPOINT_OBJ_TARGET_TYPE}
-      OBJECT_FILE "$<TARGET_OBJECTS:${fq_target_name}>"
-      CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
-      DEPS "${fq_deps_list}"
-      FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
-  )
-
   # We only build the internal target for a single supported architecture.
-  set(internal_target_name ${fq_target_name}.__internal__)
   set(include_dirs ${LIBC_BUILD_DIR}/include ${LIBC_SOURCE_DIR} ${LIBC_BUILD_DIR})
   if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU OR
      LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
     add_library(
       ${internal_target_name}
       EXCLUDE_FROM_ALL
       OBJECT
-      ${ADD_ENTRYPOINT_OBJ_SRCS}
-      ${ADD_ENTRYPOINT_OBJ_HDRS}
+      ${ADD_GPU_OBJ_SRCS}
+      ${ADD_GPU_OBJ_HDRS}
     )
     target_compile_options(${internal_target_name} BEFORE PRIVATE
                            ${common_compile_options} --target=${LIBC_GPU_TARGET_TRIPLE})
     if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
       target_compile_options(${internal_target_name} PRIVATE -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE})
     elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
       target_compile_options(${internal_target_name} PRIVATE -march=${LIBC_GPU_TARGET_ARCHITECTURE})
     endif()
     target_include_directories(${internal_target_name} PRIVATE ${include_dirs})
+    if(full_deps_list)
       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}"
-    )
-    set_target_properties(
-      ${fq_target_name}
-      PROPERTIES OBJECT_FILE_RAW "$<TARGET_OBJECTS:${internal_target_name}>"
-    )
+    endif()
   endif()
 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>
 #       FLAGS <optional list of flags>
 function(create_object_library fq_target_name)
   cmake_parse_arguments(
     "ADD_OBJECT"
-    "" # No optional arguments
+    "NO_GPU_BUNDLE" # No optional arguments
     "CXX_STANDARD" # Single value 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()
 
+  # The GPU build uses a separate internal file.
+  if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT ${ADD_OBJECT_NO_GPU_BUNDLE})
+    set(internal_target_name ${fq_target_name}.__internal__)
+  else()
+    set(internal_target_name ${fq_target_name})
+  endif()
+
+  get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
+  _get_common_compile_options(
+    compile_options
+    "${ADD_OBJECT_FLAGS}"
+    ${ADD_OBJECT_COMPILE_OPTIONS}
+  )
+
+  # GPU builds require special handling for the objects because we want to
+  # export several different targets at once, e.g. for both Nvidia and AMD.
+  if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT ${ADD_OBJECT_NO_GPU_BUNDLE})
+    _build_gpu_objects(
+      ${fq_target_name}
+      ${internal_target_name}
+      SRCS ${ADD_OBJECT_SRCS}
+      HDRS ${ADD_OBJECT_HDRS}
+      DEPENDS ${fq_deps_list}
+      COMPILE_OPTIONS ${common_compile_options}
+      FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
+    )
+  else()
     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_FLAGS}"
-    ${ADD_OBJECT_COMPILE_OPTIONS}
-  )
     target_compile_options(${fq_target_name} PRIVATE ${compile_options})
-
-  get_fq_deps_list(fq_deps_list ${ADD_OBJECT_DEPENDS})
+  endif()
 
   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(NOT ADD_OBJECT_CXX_STANDARD)
     set(ADD_OBJECT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
   endif()
   set_target_properties(
     ${fq_target_name}
     PROPERTIES
       TARGET_TYPE ${OBJECT_LIBRARY_TARGET_TYPE}
-      OBJECT_FILES "$<TARGET_OBJECTS:${fq_target_name}>"
       CXX_STANDARD ${ADD_OBJECT_CXX_STANDARD}
       DEPS "${fq_deps_list}"
       FLAGS "${ADD_OBJECT_FLAGS}"
   )
+
+  if(TARGET ${internal_target_name})
+    set_target_properties(
+      ${fq_target_name}
+      PROPERTIES
+        OBJECT_FILES "$<TARGET_OBJECTS:${internal_target_name}>"
+    )
+  endif()
 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
if(${SHOW_INTERMEDIATE_OBJECTS} STREQUAL "DEPS")
         message(STATUS "  ${fq_target_name} depends on ${dep}")
       endforeach()
     endif()
   endif()
 
   # GPU builds require special handling for the objects because we want to
   # export several different targets at once, e.g. for both Nvidia and AMD.
   if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
-    _build_gpu_entrypoint_objects(
+    _build_gpu_objects(
       ${fq_target_name}
+      ${internal_target_name}
       SRCS ${ADD_ENTRYPOINT_OBJ_SRCS}
       HDRS ${ADD_ENTRYPOINT_OBJ_HDRS}
       COMPILE_OPTIONS ${common_compile_options}
       DEPENDS ${full_deps_list}
-      CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
       FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
     )
   else()
     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} -DLIBC_COPT_PUBLIC_PACKAGING)
     target_include_directories(${fq_target_name} PRIVATE ${include_dirs})
     add_dependencies(${fq_target_name} ${full_deps_list})
+  endif()
 
-    set_target_properties(
-      ${fq_target_name}
-      PROPERTIES
-        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}>"
-        CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
-        DEPS "${fq_deps_list}"
-        FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
-    )
+
+  if(TARGET ${internal_target_name})
+    set_target_properties(
+      ${internal_target_name}
+      PROPERTIES
+        CXX_STANDARD ${ADD_ENTRYPOINT_OBJ_CXX_STANDARD}
+        FLAGS "${ADD_ENTRYPOINT_OBJ_FLAGS}"
+    )
+    set_target_properties(
+      ${fq_target_name}
+      PROPERTIES
+        # 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}>"
+    )
   endif()
 
+
   if(LLVM_LIBC_ENABLE_LINTING AND TARGET ${internal_target_name})
     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()
 
     # We only want a second invocation of clang-tidy to run
     # restrict-system-libc-headers if the compiler-resource-dir was set in

libc/startup/gpu/amdgpu/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   COMPILE_OPTIONS
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
     -nogpulib # Do not include any GPU vendor libraries.
     -nostdinc
     -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE}
     -emit-llvm # AMDGPU's intermediate object file format is bitcode.
     --target=${LIBC_GPU_TARGET_TRIPLE}
+  NO_GPU_BUNDLE # Compile this file directly without special GPU handling.
 )
 get_fq_target_name(crt1 fq_name)
 
 # Ensure that clang uses the correct linker for this object type.
 target_link_libraries(${fq_name} PUBLIC "--target=${LIBC_GPU_TARGET_TRIPLE}")

libc/startup/gpu/nvptx/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   COMPILE_OPTIONS
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
     -nogpulib # Do not include any GPU vendor libraries.
     -nostdinc
     -x cuda # Use the CUDA toolchain to emit the `_start` kernel.
     --offload-device-only
     --offload-arch=${LIBC_GPU_TARGET_ARCHITECTURE}
+  NO_GPU_BUNDLE # Compile this file directly without special GPU handling.
 )
 get_fq_target_name(crt1 fq_name)
 
 # Ensure that clang uses the correct linker for this object type.
 target_link_libraries(${fq_name} PUBLIC "--target=${LIBC_GPU_TARGET_TRIPLE}")