function(collect_object_file_deps target result)
  # NOTE: This function does add entrypoint targets to |result|.
  # It is expected that the caller adds them separately.
  set(all_deps "")
  get_target_property(target_type ${target} "TARGET_TYPE")
  if(NOT target_type)
    return()
  endif()

  if(${target_type} STREQUAL ${OBJECT_LIBRARY_TARGET_TYPE})
    list(APPEND all_deps ${target})
    get_target_property(deps ${target} "DEPS")
    foreach(dep IN LISTS deps)
      collect_object_file_deps(${dep} dep_targets)
      list(APPEND all_deps ${dep_targets})
    endforeach(dep)
    list(REMOVE_DUPLICATES all_deps)
    set(${result} ${all_deps} PARENT_SCOPE)
    return()
  endif()

  if(${target_type} STREQUAL ${ENTRYPOINT_OBJ_TARGET_TYPE} OR
     ${target_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})
    set(entrypoint_target ${target})
    get_target_property(is_alias ${entrypoint_target} "IS_ALIAS")
    if(is_alias)
      get_target_property(aliasee ${entrypoint_target} "DEPS")
      if(NOT aliasee)
        message(FATAL_ERROR
                "Entrypoint alias ${entrypoint_target} does not have an aliasee.")
      endif()
      set(entrypoint_target ${aliasee})
    endif()
    get_target_property(deps ${target} "DEPS")
    foreach(dep IN LISTS deps)
      collect_object_file_deps(${dep} dep_targets)
      list(APPEND all_deps ${dep_targets})
    endforeach(dep)
    list(REMOVE_DUPLICATES all_deps)
    set(${result} ${all_deps} PARENT_SCOPE)
    return()
  endif()

  if(${target_type} STREQUAL ${ENTRYPOINT_EXT_TARGET_TYPE})
    # It is not possible to recursively extract deps of external dependencies.
    # So, we just accumulate the direct dep and return.
    get_target_property(deps ${target} "DEPS")
    set(${result} ${deps} PARENT_SCOPE)
    return()
  endif()
endfunction(collect_object_file_deps)

function(get_all_object_file_deps result fq_deps_list)
  set(all_deps "")
  foreach(dep ${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}) 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} OR
       ${dep_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})
      set(entrypoint_target ${dep})
      get_target_property(is_alias ${entrypoint_target} "IS_ALIAS")
      if(is_alias)
        get_target_property(aliasee ${entrypoint_target} "DEPS")
        if(NOT aliasee)
          message(FATAL_ERROR
                  "Entrypoint alias ${entrypoint_target} does not have an aliasee.")
        endif()
        set(entrypoint_target ${aliasee})
      endif()
    endif()
    list(APPEND all_deps ${entrypoint_target})
  endforeach(dep)
  list(REMOVE_DUPLICATES all_deps)
  set(${result} ${all_deps} PARENT_SCOPE)
endfunction()

# A rule to build a library from a collection of entrypoint objects and bundle
# it into a GPU fatbinary. Usage is the same as 'add_entrypoint_library'.
# Usage:
#     add_gpu_entrypoint_library(
#       DEPENDS <list of add_entrypoint_object targets>
#     )
function(add_gpu_entrypoint_library target_name base_target_name)
  cmake_parse_arguments(
    "ENTRYPOINT_LIBRARY"
    "" # No optional arguments
    "" # No single value arguments
    "DEPENDS" # Multi-value arguments
    ${ARGN}
  )
  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})
  get_all_object_file_deps(all_deps "${fq_deps_list}")

  # The GPU 'libc' needs to be exported in a format that can be linked with
  # offloading langauges like OpenMP or CUDA. This wraps every GPU object into a
  # fat binary and adds them to a static library.
  set(objects "")
  foreach(dep IN LISTS all_deps)
    set(object $<$<STREQUAL:$<TARGET_NAME_IF_EXISTS:${dep}>,${dep}>:$<TARGET_OBJECTS:${dep}>>)
    string(FIND ${dep} "." last_dot_loc REVERSE)
    math(EXPR name_loc "${last_dot_loc} + 1")
    string(SUBSTRING ${dep} ${name_loc} -1 name)
    if(LIBC_TARGET_ARCHITECTURE_IS_NVPTX)
      set(prefix --image=arch=generic,triple=nvptx64-nvidia-cuda,feature=+ptx63)
    elseif(LIBC_TARGET_ARCHITECTURE_IS_AMDGPU)
      set(prefix --image=arch=generic,triple=amdgcn-amd-amdhsa)
    endif()

    # Use the 'clang-offload-packager' to merge these files into a binary blob.
    add_custom_command(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/binary/${name}.gpubin"
      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/binary
      COMMAND ${LIBC_CLANG_OFFLOAD_PACKAGER}
              "${prefix},file=$<JOIN:${object},,file=>" -o
              ${CMAKE_CURRENT_BINARY_DIR}/binary/${name}.gpubin
      DEPENDS ${dep} ${base_target_name}
      COMMENT "Packaging LLVM offloading binary for '${object}'"
    )
    add_custom_target(${dep}.__gpubin__ DEPENDS ${dep}
                      "${CMAKE_CURRENT_BINARY_DIR}/binary/${name}.gpubin")
    if(TARGET clang-offload-packager)
      add_dependencies(${dep}.__gpubin__ clang-offload-packager)
    endif()

    # CMake does not permit setting the name on object files. In order to have
    # human readable names we create an empty stub file with the entrypoint
    # name. This empty file will then have the created binary blob embedded.
    add_custom_command(
      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/stubs/${name}.cpp"
      COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/stubs
      COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/stubs/${name}.cpp
      DEPENDS ${dep} ${dep}.__gpubin__ ${base_target_name}
    )
    add_custom_target(${dep}.__stub__
                      DEPENDS ${dep}.__gpubin__ "${CMAKE_CURRENT_BINARY_DIR}/stubs/${name}.cpp")

    add_library(${dep}.__fatbin__
      EXCLUDE_FROM_ALL OBJECT
      "${CMAKE_CURRENT_BINARY_DIR}/stubs/${name}.cpp"
    )

    # This is always compiled for the LLVM host triple instead of the native GPU
    # triple that is used by default in the build.
    target_compile_options(${dep}.__fatbin__ BEFORE PRIVATE -nostdlib)
    target_compile_options(${dep}.__fatbin__ PRIVATE
      --target=${LLVM_HOST_TRIPLE}
      "SHELL:-Xclang -fembed-offload-object=${CMAKE_CURRENT_BINARY_DIR}/binary/${name}.gpubin")
    add_dependencies(${dep}.__fatbin__
                     ${dep} ${dep}.__stub__ ${dep}.__gpubin__ ${base_target_name})

    # Set the list of newly create fat binaries containing embedded device code.
    list(APPEND objects $<TARGET_OBJECTS:${dep}.__fatbin__>)
  endforeach()

  add_library(
    ${target_name}
    STATIC
      ${objects}
  )
  set_target_properties(${target_name} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${LIBC_LIBRARY_DIR})
endfunction(add_gpu_entrypoint_library)

# A rule to build a library from a collection of entrypoint objects and bundle
# it in a single LLVM-IR bitcode file.
# Usage:
#     add_gpu_entrypoint_library(
#       DEPENDS <list of add_entrypoint_object targets>
#     )
function(add_bitcode_entrypoint_library target_name base_target_name)
  cmake_parse_arguments(
    "ENTRYPOINT_LIBRARY"
    "" # No optional arguments
    "" # No single value arguments
    "DEPENDS" # Multi-value arguments
    ${ARGN}
  )
  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})
  get_all_object_file_deps(all_deps "${fq_deps_list}")

  set(objects "")
  foreach(dep IN LISTS all_deps)
    set(object $<$<STREQUAL:$<TARGET_NAME_IF_EXISTS:${dep}>,${dep}>:$<TARGET_OBJECTS:${dep}>>)
    list(APPEND objects ${object})
  endforeach()

  set(output ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.bc)
  add_custom_command(
    OUTPUT ${output}
    COMMAND ${LIBC_LLVM_LINK} ${objects} -o ${output}
    DEPENDS ${all_deps} ${base_target_name}
    COMMENT "Linking LLVM-IR bitcode for ${base_target_name}"
    COMMAND_EXPAND_LISTS
  )
  add_custom_target(${target_name} DEPENDS ${output} ${all_deps})
  set_target_properties(${target_name} PROPERTIES TARGET_OBJECT ${output})
  if(TARGET llvm-link)
    add_dependencies(${target_name} llvm-link)
  endif()
endfunction(add_bitcode_entrypoint_library)

# A rule to build a library from a collection of entrypoint objects.
# Usage:
#     add_entrypoint_library(
#       DEPENDS <list of add_entrypoint_object targets>
#     )
#
# NOTE: If one wants an entrypoint to be available in a library, then they will
# have to list the entrypoint target explicitly in the DEPENDS list. Implicit
# entrypoint dependencies will not be added to the library.
function(add_entrypoint_library target_name)
  cmake_parse_arguments(
    "ENTRYPOINT_LIBRARY"
    "" # No optional arguments
    "" # No single value arguments
    "DEPENDS" # Multi-value arguments
    ${ARGN}
  )
  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})
  get_all_object_file_deps(all_deps "${fq_deps_list}")

  set(objects "")
  foreach(dep IN LISTS all_deps)
    list(APPEND objects $<$<STREQUAL:$<TARGET_NAME_IF_EXISTS:${dep}>,${dep}>:$<TARGET_OBJECTS:${dep}>>)
  endforeach(dep)

  add_library(
    ${target_name}
    STATIC
    ${objects}
  )
  set_target_properties(${target_name} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${LIBC_LIBRARY_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"
    ${ARGN}
  )

  set(obj_files "")
  foreach(dep IN LISTS REDIRECTOR_LIBRARY_DEPENDS)
    # TODO: Ensure that each dep is actually a add_redirector_object target.
    list(APPEND obj_files $<TARGET_OBJECTS:${dep}>)
  endforeach(dep)

  # 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 ${LIBC_LIBRARY_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")

# Internal function, used by `add_header_library`.
function(create_header_library fq_target_name)
  cmake_parse_arguments(
    "ADD_HEADER"
    "" # Optional arguments
    "" # Single value arguments
    "HDRS;DEPENDS;FLAGS;COMPILE_OPTIONS" # Multi-value arguments
    ${ARGN}
  )

  if(NOT ADD_HEADER_HDRS)
    message(FATAL_ERROR "'add_header_library' target requires a HDRS list of .h files.")
  endif()

  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()

  add_library(${fq_target_name} INTERFACE)
  target_sources(${fq_target_name} INTERFACE ${ADD_HEADER_HDRS})
  if(ADD_HEADER_DEPENDS)
    add_dependencies(${fq_target_name} ${ADD_HEADER_DEPENDS})

    # `*.__copied_hdr__` is created only to copy the header files to the target
    # location, not to be linked against.
    set(link_lib "")
    foreach(dep ${ADD_HEADER_DEPENDS})
      if (NOT dep MATCHES "__copied_hdr__")
        list(APPEND link_lib ${dep})
      endif()
    endforeach()

    target_link_libraries(${fq_target_name} INTERFACE ${link_lib})
  endif()
  if(ADD_HEADER_COMPILE_OPTIONS)
    target_compile_options(${fq_target_name} INTERFACE ${ADD_HEADER_COMPILE_OPTIONS})
  endif()
  set_target_properties(
    ${fq_target_name}
    PROPERTIES
      INTERFACE_FLAGS "${ADD_HEADER_FLAGS}"
      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>
#    )

function(add_header_library target_name)
  add_target_with_flags(
    ${target_name}
    CREATE_TARGET create_header_library
    ${ARGN}
  )
endfunction(add_header_library)