[SYCL][libdevice] Refactor cmake for imf SYCL device library (#6312)

This PR aims to refactor cmake building system for imf SYCL device library. Previously, the source of SYCL fallback device library has pre-assumption that all functions in the same fallback .spv or .o file must reside in single .cpp file. The reason is we need to use sycl compiler to build .spv or .o file with following commands:
clang++ -fsycl -fsycl-device-only -fno-sycl-use-bitcode t.cpp -o t.spv
clang++ -fsycl -c -fsycl-targets="..." t.cpp -o t.o

However, imf fallback sources broke the pre-assumptions, all implementations reside in multiple .cpp files. Current building have to deal with multiple tools, for spv building, we have to do following:

use "clang++ -fsycl -fsycl-device-only -c -emit-llvm" to generate LLVM .bc file for each .cpp
use "llvm-link" to link multiple LLVM .bc into one LLVM .bc file
use "llvm-spirv" to convert the LLVM .bc to spirv file
For .o file, the steps are more complicated, we need to do following:

use "clang++ -fsycl -fsycl-device-only -c -emit-llvm" to generate LLVM.bc for each .cpp
Use "llvm-link" to link multiple LLVM .bc into one LLVM .bc file
the steps 1,2 must be done for all sycl targets supported
use clang-offload-bunlder to bundle different sycl target's LLVM .bc to final .objet file
Current solution has following drawbacks:

Too complicated, too much unnecessary work which is to emulate the work of simple “clang++ -fsycl …” command. This makes cmake hard to understand and maintain.
Too fragile, clang driver may change the detail steps of simple “clang++ -fsycl…” and each tool used currently may update their option and usage which may lead to imf libdevice building failure. The more tools we deal with, the more risk we are in.
So, we decide to use following solution:
For building imf fallback spv or object file, we first combine all required .cpp into a “full” .cpp and then use simple “clang++ -fsycl …” command to build it. We will create a “libdevice” folder in build/lib and save the full .cpp file there.
All imf fallback device library code will be organized to avoid code conflict, duplicate.

Signed-off-by: jinge90 ge.jin@intel.com

Author: jinge90

libdevice/cmake/modules/ImfSrcConcate.cmake

@@ -0,0 +1,26 @@
+set(imf_fp32_fallback_src_list imf_utils/integer_misc.cpp
+                               imf_utils/half_convert.cpp
+                               imf_utils/float_convert.cpp
+                               imf/imf_inline_fp32.cpp)
+
+set(imf_fp64_fallback_src_list imf_utils/double_convert.cpp
+                               imf/imf_inline_fp64.cpp)
+
+if (FP64 STREQUAL 0)
+  set(imf_fallback_src_list ${imf_fp32_fallback_src_list})
+  set(imf_fallback_dest ${DEST_DIR}/imf_fp32_fallback.cpp)
+else()
+  set(imf_fallback_src_list ${imf_fp64_fallback_src_list})
+  set(imf_fallback_dest ${DEST_DIR}/imf_fp64_fallback.cpp)
+endif()
+
+set(flag 0)
+foreach(src ${imf_fallback_src_list})
+  file(READ ${SRC_DIR}/${src} src_contents)
+  if(flag STREQUAL 0)
+    file(WRITE ${imf_fallback_dest} "${src_contents}")
+    set(flag 1)
+  else()
+    file(APPEND ${imf_fallback_dest} "${src_contents}")
+  endif()
+endforeach()

libdevice/cmake/modules/SYCLLibdevice.cmake

@@ -13,11 +13,7 @@ endif()
 set(install_dest_lib lib${LLVM_LIBDIR_SUFFIX})
 
 set(clang $<TARGET_FILE:clang>)
-set(llvm-link $<TARGET_FILE:llvm-link>)
-set(llc $<TARGET_FILE:llc>)
-set(llvm-spirv $<TARGET_FILE:llvm-spirv>)
 set(llvm-ar $<TARGET_FILE:llvm-ar>)
-set(clang-offload-bundler $<TARGET_FILE:clang-offload-bundler>)
 
 string(CONCAT sycl_targets_opt
   "-fsycl-targets="
@@ -120,162 +116,131 @@ add_fallback_devicelib(libsycl-fallback-complex-fp64 SRC fallback-complex-fp64.c
 add_fallback_devicelib(libsycl-fallback-cmath SRC fallback-cmath.cpp DEP ${cmath_obj_deps})
 add_fallback_devicelib(libsycl-fallback-cmath-fp64 SRC fallback-cmath-fp64.cpp DEP ${cmath_obj_deps})
 
-# imf fallback is different, we have many separate sources instead of single one including all functions.
-# So, we need to combine all LLVM IR to a complete one and run llvm-spirv for it.
 file(MAKE_DIRECTORY ${obj_binary_dir}/libdevice)
-set(bc_binary_dir ${obj_binary_dir}/libdevice)
-
-set(fallback-imf-src imf_utils/float_convert.cpp
-                     imf_utils/half_convert.cpp
-                     imf_utils/integer_misc.cpp
-                     imf/imf_inline_fp32.cpp)
-set(fallback-imf-fp64-src imf_utils/double_convert.cpp
-                          imf/imf_inline_fp64.cpp)
-set(wrapper-imf-src imf_wrapper.cpp imf_wrapper_fp64.cpp)
-set(imf-src ${wrapper-imf-src} ${fallback-imf-src} ${fallback-imf-fp64-src})
-
-add_custom_target(imf-fallback-spv
-                  COMMAND ${llvm-spirv}
-                           ${bc_binary_dir}/fallback-imf-spir64-unknown-unknown.bc
-                           -o ${spv_binary_dir}/libsycl-fallback-imf.spv)
-add_custom_target(imf-fp64-fallback-spv
-                  COMMAND ${llvm-spirv}
-                  ${bc_binary_dir}/fallback-imf-fp64-spir64-unknown-unknown.bc
-                  -o ${spv_binary_dir}/libsycl-fallback-imf-fp64.spv)
-     
-add_dependencies(libsycldevice-spv imf-fallback-spv)
-add_dependencies(libsycldevice-spv imf-fp64-fallback-spv)
+set(imf_fallback_src_dir ${obj_binary_dir}/libdevice)
+set(imf_src_dir ${CMAKE_CURRENT_SOURCE_DIR})
+set(imf_fallback_fp32_deps device.h device_imf.hpp imf_half.hpp
+                           imf_utils/integer_misc.cpp
+                           imf_utils/float_convert.cpp
+                           imf_utils/half_convert.cpp
+                           imf/imf_inline_fp32.cpp)
+set(imf_fallback_fp64_deps device.h device_imf.hpp imf_half.hpp
+                           imf_utils/double_convert.cpp
+                           imf/imf_inline_fp64.cpp)
+set(imf_fp32_fallback_src ${imf_fallback_src_dir}/imf_fp32_fallback.cpp)
+set(imf_fp64_fallback_src ${imf_fallback_src_dir}/imf_fp64_fallback.cpp)
+
+add_custom_command(OUTPUT ${imf_fp32_fallback_src}
+                   COMMAND ${CMAKE_COMMAND} -D SRC_DIR=${imf_src_dir}
+                                            -D DEST_DIR=${imf_fallback_src_dir}
+                                            -D FP64=0
+                                            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/ImfSrcConcate.cmake
+                   DEPENDS ${imf_fallback_fp32_deps})
+
+add_custom_command(OUTPUT ${imf_fp64_fallback_src}
+                   COMMAND ${CMAKE_COMMAND} -D SRC_DIR=${imf_src_dir}
+                                            -D DEST_DIR=${imf_fallback_src_dir}
+                                            -D FP64=1
+                                            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/ImfSrcConcate.cmake
+                   DEPENDS ${imf_fallback_fp64_deps})
+
+add_custom_target(get_imf_fallback_fp32  DEPENDS ${imf_fp32_fallback_src})
+add_custom_command(OUTPUT ${spv_binary_dir}/libsycl-fallback-imf.spv
+                   COMMAND ${clang} -fsycl-device-only -fno-sycl-use-bitcode
+                           ${compile_opts} -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           ${imf_fp32_fallback_src}
+                           -o ${spv_binary_dir}/libsycl-fallback-imf.spv
+                   DEPENDS ${imf_fallback_fp32_deps} get_imf_fallback_fp32
+                   VERBATIM)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/libsycl-fallback-imf.${lib-suffix}
+                   COMMAND ${clang} -fsycl -c
+                           ${compile_opts} ${sycl_targets_opt}
+                           ${imf_fp32_fallback_src} -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           -o ${obj_binary_dir}/libsycl-fallback-imf.${lib-suffix}
+                   DEPENDS ${imf_fallback_fp32_deps} get_imf_fallback_fp32
+                   VERBATIM)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/fallback-imf-fp32-host.${lib-suffix}
+                   COMMAND ${clang} -c -D__LIBDEVICE_HOST_IMPL__
+                           -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           ${imf_fp32_fallback_src}
+                           -o ${obj_binary_dir}/fallback-imf-fp32-host.${lib-suffix}
+                   DEPENDS ${imf_fallback_fp32_deps} get_imf_fallback_fp32
+                   VERBATIM)
+
+add_custom_target(get_imf_fallback_fp64  DEPENDS ${imf_fp64_fallback_src})
+add_custom_command(OUTPUT ${spv_binary_dir}/libsycl-fallback-imf-fp64.spv
+                   COMMAND ${clang} -fsycl-device-only -fno-sycl-use-bitcode
+                           ${compile_opts} -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           ${imf_fp64_fallback_src}
+                           -o ${spv_binary_dir}/libsycl-fallback-imf-fp64.spv
+                   DEPENDS ${imf_fallback_fp64_deps} get_imf_fallback_fp64
+                   VERBATIM)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/libsycl-fallback-imf-fp64.${lib-suffix}
+                   COMMAND ${clang} -fsycl -c -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           ${compile_opts} ${sycl_targets_opt}
+                           ${imf_fp64_fallback_src}
+                           -o ${obj_binary_dir}/libsycl-fallback-imf-fp64.${lib-suffix}
+                   DEPENDS ${imf_fallback_fp64_deps} get_imf_fallback_fp64
+                   VERBATIM)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/fallback-imf-fp64-host.${lib-suffix}
+                   COMMAND ${clang} -c -D__LIBDEVICE_HOST_IMPL__
+                           -I ${CMAKE_CURRENT_SOURCE_DIR}/imf
+                           ${imf_fp64_fallback_src}
+                           -o ${obj_binary_dir}/fallback-imf-fp64-host.${lib-suffix}
+                   DEPENDS ${imf_fallback_fp64_deps} get_imf_fallback_fp64
+                   VERBATIM)
+
+add_custom_target(imf_fallback_fp32_spv DEPENDS ${spv_binary_dir}/libsycl-fallback-imf.spv)
+add_custom_target(imf_fallback_fp32_obj DEPENDS ${obj_binary_dir}/libsycl-fallback-imf.${lib-suffix})
+add_custom_target(imf_fallback_fp32_host_obj DEPENDS ${obj_binary_dir}/fallback-imf-fp32-host.${lib-suffix})
+add_dependencies(libsycldevice-spv imf_fallback_fp32_spv)
+add_dependencies(libsycldevice-obj imf_fallback_fp32_obj)
+
+add_custom_target(imf_fallback_fp64_spv DEPENDS ${spv_binary_dir}/libsycl-fallback-imf-fp64.spv)
+add_custom_target(imf_fallback_fp64_obj DEPENDS ${obj_binary_dir}/libsycl-fallback-imf-fp64.${lib-suffix})
+add_custom_target(imf_fallback_fp64_host_obj DEPENDS ${obj_binary_dir}/fallback-imf-fp64-host.${lib-suffix})
+add_dependencies(libsycldevice-spv imf_fallback_fp64_spv)
+add_dependencies(libsycldevice-obj imf_fallback_fp64_obj)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/imf-fp32-host.${lib-suffix}
+                   COMMAND ${clang} -c -D__LIBDEVICE_HOST_IMPL__
+                           ${CMAKE_CURRENT_SOURCE_DIR}/imf_wrapper.cpp
+                           -o ${obj_binary_dir}/imf-fp32-host.${lib-suffix}
+                   MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/imf_wrapper.cpp
+                   DEPENDS ${imf_obj_deps}
+                   VERBATIM)
+
+add_custom_command(OUTPUT ${obj_binary_dir}/imf-fp64-host.${lib-suffix}
+                   COMMAND ${clang} -c -D__LIBDEVICE_HOST_IMPL__
+                           ${CMAKE_CURRENT_SOURCE_DIR}/imf_wrapper_fp64.cpp
+                           -o ${obj_binary_dir}/imf-fp64-host.${lib-suffix}
+                   MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/imf_wrapper_fp64.cpp
+                   DEPENDS ${imf_obj_deps}
+                   VERBATIM)
+
+add_custom_target(imf_fp32_host_obj DEPENDS ${obj_binary_dir}/imf-fp32-host.${lib-suffix})
+add_custom_target(imf_fp64_host_obj DEPENDS ${obj_binary_dir}/imf-fp64-host.${lib-suffix})
+add_custom_target(imf_host_obj
+                  COMMAND ${llvm-ar} rcs ${obj_binary_dir}/${devicelib_host_static}
+                          ${obj_binary_dir}/imf-fp32-host.${lib-suffix}
+                          ${obj_binary_dir}/fallback-imf-fp32-host.${lib-suffix}
+                          ${obj_binary_dir}/imf-fp64-host.${lib-suffix}
+                          ${obj_binary_dir}/fallback-imf-fp64-host.${lib-suffix}
+                  DEPENDS imf_fp32_host_obj imf_fallback_fp32_host_obj imf_fp64_host_obj imf_fallback_fp64_host_obj
+                  VERBATIM)
+add_dependencies(libsycldevice-obj imf_host_obj)
 install(FILES ${spv_binary_dir}/libsycl-fallback-imf.spv
               ${spv_binary_dir}/libsycl-fallback-imf-fp64.spv
         DESTINATION ${install_dest_spv}
         COMPONENT libsycldevice)
 
-set(sycl_offload_targets sycl-spir64_x86_64-unknown-unknown
-    sycl-spir64_gen-unknown-unknown
-    sycl-spir64_fpga-unknown-unknown
-    sycl-spir64-unknown-unknow
-    host-x86_64-unknown-linux-gnu)
-
-string(REPLACE ";" "," sycl_offload_targets "${sycl_offload_targets}")
-set(imf-offload-inputs ${bc_binary_dir}/fallback-imf-spir64-unknown-unknown.bc
-                       ${bc_binary_dir}/fallback-imf-spir64_x86_64-unknown-unknown.bc
-                       ${bc_binary_dir}/fallback-imf-spir64_gen-unknown-unknown.bc
-                       ${bc_binary_dir}/fallback-imf-spir64_fpga-unknown-unknown.bc
-                       ${bc_binary_dir}/fallback-imf-dummy-host.bc)
-string(REPLACE ";" "," imf-offload-inputs "${imf-offload-inputs}")
-add_custom_target(imf-fallback-obj
-                 COMMAND ${clang-offload-bundler} -type=o -targets=${sycl_offload_targets}
-                 -outputs=${obj_binary_dir}/libsycl-fallback-imf.${lib-suffix}
-                 -inputs=${imf-offload-inputs})
-
-add_dependencies(libsycldevice-obj imf-fallback-obj)
-
-set(imf-fp64-offload-inputs ${bc_binary_dir}/fallback-imf-fp64-spir64-unknown-unknown.bc
-                            ${bc_binary_dir}/fallback-imf-fp64-spir64_x86_64-unknown-unknown.bc
-                            ${bc_binary_dir}/fallback-imf-fp64-spir64_gen-unknown-unknown.bc
-                            ${bc_binary_dir}/fallback-imf-fp64-spir64_fpga-unknown-unknown.bc
-                            ${bc_binary_dir}/fallback-imf-fp64-dummy-host.bc)
-string(REPLACE ";" "," imf-fp64-offload-inputs "${imf-fp64-offload-inputs}")
-add_custom_target(imf-fp64-fallback-obj
-                 COMMAND ${clang-offload-bundler} -type=o -targets=${sycl_offload_targets}
-                 -outputs=${obj_binary_dir}/libsycl-fallback-imf-fp64.${lib-suffix}
-                 -inputs=${imf-fp64-offload-inputs})
-
-add_dependencies(libsycldevice-obj imf-fp64-fallback-obj)
-
 install(FILES ${obj_binary_dir}/libsycl-fallback-imf.${lib-suffix}
               ${obj_binary_dir}/libsycl-fallback-imf-fp64.${lib-suffix}
+              ${obj_binary_dir}/${devicelib_host_static}
         DESTINATION ${install_dest_lib}
         COMPONENT libsycldevice)
 
-function(add_devicelib_bc src_file sycl_target)
-  cmake_parse_arguments(BC "" "" "DEPS;DEPED" ${ARGN})
-  get_filename_component(fn ${src_file} NAME_WE)
-  set(temp_bc_fn ${fn}-${sycl_target}.bc)
-  set(devicelib-bc ${bc_binary_dir}/${temp_bc_fn})
-  if(sycl_target STREQUAL "dummy-host")
-    set(bc_compile_flags -c -emit-llvm)
-  elseif(sycl_target STREQUAL "host")
-    set(bc_compile_flags -c -emit-llvm -D__LIBDEVICE_HOST_IMPL__)
-  else()
-    set(bc_compile_flags -fsycl -fsycl-device-only -fsycl-targets=${sycl_target})
-  endif()
-  if (WIN32)
-    list(APPEND bc_compile_flags -D_ALLOW_RUNTIME_LIBRARY_MISMATCH)
-    list(APPEND bc_compile_flags -D_ALLOW_ITERATOR_DEBUG_LEVEL_MISMATCH)
-  endif()
-  add_custom_command(OUTPUT ${devicelib-bc}
-                     COMMAND ${clang} ${bc_compile_flags}
-                             ${CMAKE_CURRENT_SOURCE_DIR}/${src_file}
-                             -o ${devicelib-bc}
-                     MAIN_DEPENDENCY ${src_file}
-                     DEPENDS ${BC_DEPS}
-                     VERBATIM)
-  add_custom_target(${temp_bc_fn} DEPENDS ${devicelib-bc})
-  add_dependencies(${BC_DEPED} ${temp_bc_fn})
-endfunction()
-
-function(merge_devicelib_bc bc_filename sycl_target)
-  cmake_parse_arguments(FBC  "" "" "SRCS;DEPS;DEPED" ${ARGN})
-  set(bc_file_list)
-  foreach(src ${FBC_SRCS})
-    get_filename_component(fn ${src} NAME_WE)
-    set(temp_bc_fn ${fn}-${sycl_target}.bc)
-    list(APPEND bc_file_list ${bc_binary_dir}/${temp_bc_fn})
-  endforeach()
-  set(bc_target ${bc_filename}-${sycl_target})
-  add_custom_target(${bc_target}
-                    COMMAND ${llvm-link} ${bc_file_list} -o ${bc_binary_dir}/${bc_target}.bc
-                    VERBATIM)
-  foreach(src ${FBC_SRCS})
-    add_devicelib_bc(${src} ${sycl_target}
-                  DEPS ${FBC_DEPS}
-                  DEPED ${bc_target})
-  endforeach()
-  foreach(deped ${FBC_DEPED})
-    add_dependencies(${deped} ${bc_target})
-  endforeach()
-endfunction()
-
-set(imf_sycl_targets spir64_x86_64-unknown-unknown
-    spir64_gen-unknown-unknown
-    spir64_fpga-unknown-unknown
-    spir64-unknown-unknown
-    dummy-host)
-
-foreach(imf_target ${imf_sycl_targets})
-  if(imf_target STREQUAL "spir64-unknown-unknown")
-    set(deped_list imf-fallback-obj imf-fallback-spv)
-    set(deped64_list imf-fp64-fallback-obj imf-fp64-fallback-spv)
-  else()
-    set(deped_list imf-fallback-obj)
-    set(deped64_list imf-fp64-fallback-obj)
-  endif()
-  merge_devicelib_bc(fallback-imf ${imf_target}
-                     SRCS ${fallback-imf-src}
-                     DEPS ${imf_obj_deps}
-                     DEPED ${deped_list})
-
-  merge_devicelib_bc(fallback-imf-fp64 ${imf_target}
-                     SRCS ${fallback-imf-fp64-src}
-                     DEPS ${imf_obj_deps}
-                     DEPED ${deped64_list})
-endforeach()
-
-add_custom_target(imf-host-obj
-                  COMMAND ${llc} -filetype=obj
-                          ${bc_binary_dir}/imf-host.bc -o
-                          ${bc_binary_dir}/imf-host.${lib-suffix}
-                  COMMAND ${llvm-ar} rcs ${obj_binary_dir}/${devicelib_host_static} ${bc_binary_dir}/imf-host.${lib-suffix}
-                  VERBATIM)
-
-add_dependencies(libsycldevice imf-host-obj)
-
-install(FILES ${obj_binary_dir}/${devicelib_host_static}
-        DESTINATION ${install_dest_lib}
-        COMPONENT libsycldevice)
-
-merge_devicelib_bc(imf host
-                   SRCS ${imf-src}
-                   DEPS ${imf_obj_deps}
-                   DEPED imf-host-obj)

libdevice/device.h

@@ -32,7 +32,11 @@
 #endif // __SPIR__ || __LIBDEVICE_HOST_IMPL__
 
 #ifdef __LIBDEVICE_HOST_IMPL__
-#define DEVICE_EXTERN_C __attribute__((weak)) EXTERN_C
+// For host implementation, all functions will be located in a static library
+// and it will be linked with user's host code by default. If those functions
+// are decorated with "weak" attribute, compiler will use PLT entry to call
+// all __device_imf_* functions, this will lead to crash.
+#define DEVICE_EXTERN_C EXTERN_C
 #define DEVICE_EXTERN_C_INLINE DEVICE_EXTERN_C __attribute__((always_inline))
 #endif // __LIBDEVICE_HOST_IMPL__