[openmp] - Use mlink-builtin-bitcode for libomptarget.

- No longer use llvm-link for linking of ocml.bc
and ockl.bc for libomptarget.
- Created Platform.h which uses aliaes so clang can
emit libdevice control constants with ODRLinkage
to allow usage of mlink-builtin-bitcode.
- Move libm inside of DeviceRTL which takes care of
some undefined symbols left in user applications.
- Added Platform.h to hostexec_stubs which resolved
and -O0 compilation issue.
- prep-libomptarget-bc has a new function that only
marks ockl_dm_alloc and ockl_dm_dealloc as linkonce_odr
to properly use our version of ockl_devmem_request to
levarage hostexec.
- Remove --attributor-enable=module from DeviceRTL
as it was causing LibM sin/cos functions to be
over optimized causing NaN values.

Change-Id: I4fc7023a61a3aa407b0f71e95a689dbda2aab15b

Author: jhuber6

clang/lib/Driver/ToolChains/AMDGPUOpenMP.cpp

@@ -455,6 +455,12 @@ void AMDGPUOpenMPToolChain::addClangTargetOptions(
   if (DriverArgs.hasArg(options::OPT_nogpulib))
     return;
 
+  for (auto BCFile : getDeviceLibs(DriverArgs)) {
+    CC1Args.push_back(BCFile.ShouldInternalize ? "-mlink-builtin-bitcode"
+                                               : "-mlink-bitcode-file");
+    CC1Args.push_back(DriverArgs.MakeArgString(BCFile.Path));
+  }
+
   ArgStringList LibraryPaths;
 
   // Find in --hip-device-lib-path and HIP_LIBRARY_PATH.

clang/lib/Driver/ToolChains/Clang.cpp

@@ -9198,17 +9198,17 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
                                  const char *LinkingOutput) const {
   bool isAMDGPU = false;
   auto offloadTC = C.getOffloadToolChains(Action::OFK_OpenMP);
-  const auto openMPTCs = llvm::make_range(offloadTC.first, offloadTC.second);
+  const auto OpenMPTCs = llvm::make_range(offloadTC.first, offloadTC.second);
   const ToolChain *TC;
-  for (auto &I : openMPTCs) {
+  for (auto &I : OpenMPTCs) {
     TC = I.second;
     if (TC->getTriple().isAMDGPU()) {
       isAMDGPU = true;
       break;
     }
   }
 
-  if (!openMPTCs.empty() &&
+  if (!OpenMPTCs.empty() &&
       Args.hasFlag(options::OPT_opaque_offload_linker,
                    options::OPT_no_opaque_offload_linker, isAMDGPU)) {
     ConstructOpaqueJob(C, JA, Output, Inputs, Args, TC->getTriple(),
@@ -9233,35 +9233,6 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
               "--cuda-path=" + CudaInstallation.getInstallPath()));
         break;
       }
-      if (TC->getTriple().isAMDGPU()) {
-        RocmInstallationDetector RocmInstallation(D, TheTriple, Args, true,
-                                                  true);
-        const llvm::Triple triple = TC->getTriple();
-        const auto GPUArch = TC->getTargetID().str();
-        const auto ArchKind = llvm::AMDGPU::parseArchAMDGCN(TC->getTargetID());
-
-        bool AsanGpuRT = Args.hasFlag(options::OPT_fgpu_sanitize,
-                                      options::OPT_fno_gpu_sanitize, true);
-
-        llvm::SmallVector<std::string, 12> BCLibs =
-            amdgpu::dlr::getCommonDeviceLibNames(
-                Args, D, GPUArch, /* isOpenMP */ true, RocmInstallation);
-
-        SmallVector<std::string> subarchs;
-        addSubArchsWithTargetID(C, Args, triple, subarchs);
-
-        std::set<std::string> bitcodeTarget;
-        for (const auto &sa : subarchs) {
-          bitcodeTarget.insert("openmp-" + triple.str() + "-" +
-                               getProcessorFromTargetID(triple, sa).str());
-        }
-
-        for (StringRef prefix : bitcodeTarget)
-          for (auto BCLib : BCLibs)
-            CmdArgs.push_back(Args.MakeArgString("--bitcode-library=" + prefix +
-                                                 "=" + BCLib));
-        break;
-      }
     }
   }
 

clang/lib/Headers/__clang_cuda_math.h

@@ -24,15 +24,22 @@
 #pragma push_macro("__DEVICE__")
 #ifdef __OPENMP_NVPTX__
 #if defined(__cplusplus)
+#ifdef __BUILD_MATH_BUILTINS_LIB__
+#include <limits.h>
+#define HUGE_VALF (__builtin_huge_valf())
+#define HUGE_VAL (__builtin_huge_val())
+#define __DEVICE__ extern "C" __attribute__((always_inline, nothrow))
+#else
 #define __DEVICE__ static constexpr __attribute__((always_inline, nothrow))
+#endif // __BUILD_MATH_BUILTINS_LIB__
 #else
 // Use __BUILD_MATH_BUILTINS_LIB__ to build device specific libm-nvptx.bc
 // for FORTRAN bitcode linking since FORTRAN cannot use c headers.
 #ifdef __BUILD_MATH_BUILTINS_LIB__
 #include <limits.h>
 #define HUGE_VALF (__builtin_huge_valf())
 #define HUGE_VAL (__builtin_huge_val())
-#define __DEVICE__ extern __attribute__((always_inline, nothrow, cold, weak))
+#define __DEVICE__ extern __attribute__((always_inline, nothrow))
 #else
 #define __DEVICE__ static __attribute__((always_inline, nothrow))
 #endif // __BUILD_MATH_BUILTINS_LIB__

clang/lib/Headers/__clang_hip_math.h

@@ -29,12 +29,17 @@
 
 #ifdef __OPENMP_AMDGCN__
 #if defined(__cplusplus)
+#ifdef __BUILD_MATH_BUILTINS_LIB__
+#define __DEVICE__ extern "C" __attribute__((always_inline, nothrow))
+#define __DEVICE_NOCE__ __DEVICE__
+#else
 #define __DEVICE__ static constexpr __attribute__((always_inline, nothrow))
 #define __DEVICE_NOCE__ static __attribute__((always_inline, nothrow))
+#endif
 #else // !defined(__cplusplus), c openmp compilation
 // Special case to build c-only device function lib for FORTRAN.
 #ifdef __BUILD_MATH_BUILTINS_LIB__
-#define __DEVICE__ extern __attribute__((always_inline, nothrow, cold, weak))
+#define __DEVICE__ extern __attribute__((always_inline, nothrow))
 #define __DEVICE_NOCE__ __DEVICE__
 #else
 #define __DEVICE__ static __attribute__((always_inline, nothrow))
@@ -1280,7 +1285,7 @@ double __fma_rn(double __x, double __y, double __z) {
   _Generic((__x), float : __signbitf, double : __signbit)(__x)
 #endif // !defined(__cplusplus) && __STDC_VERSION__ >= 201112L
 
-#if defined(__cplusplus)
+#if defined(__cplusplus) && !defined(__BUILD_MATH_BUILTINS_LIB__)
 #ifndef __OPENMP_AMDGCN__
 template <class T> __DEVICE__ T min(T __arg1, T __arg2) {
   return (__arg1 < __arg2) ? __arg1 : __arg2;

openmp/libomptarget/CMakeLists.txt

@@ -189,17 +189,10 @@ set(LIBOMPTARGET_LLVM_LIBRARY_INTDIR "${LIBOMPTARGET_INTDIR}" CACHE STRING
 
 # Build offloading plugins and device RTLs if they are available.
 add_subdirectory(plugins-nextgen)
-# Currently device libm functions are created by clang headers.  These do not
-# work for FORTRAN. The libm here  builds a libm device library by turning on
-# __BUILD_MATH_BUILTINS_LIB__ This converts the math functions in the clang
-# headers from static to extern to build device linkable libm for FORTRAN.
-# Eventually, we can make a linkable device libm for c and c++ and remove a
-# lot of header definitions that get compiled with every offload compilation.
-add_subdirectory(libm)
 
-add_subdirectory(hostexec)
 add_subdirectory(tools)
 set(PREP_TOOL $<TARGET_FILE:prep-libomptarget-bc>)
+add_subdirectory(hostexec)
 add_subdirectory(DeviceRTL)
 
 # Build target agnostic offloading library.

openmp/libomptarget/DeviceRTL/CMakeLists.txt

@@ -93,6 +93,7 @@ list(REMOVE_DUPLICATES LIBOMPTARGET_DEVICE_ARCHITECTURES)
 set(include_files
   ${include_directory}/Allocator.h
   ${include_directory}/Configuration.h
+  ${include_directory}/Platform.h
   ${include_directory}/Debug.h
   ${include_directory}/Interface.h
   ${include_directory}/LibC.h
@@ -111,6 +112,7 @@ set(src_files
   ${source_directory}/Debug.cpp
   ${source_directory}/Kernel.cpp
   ${source_directory}/LibC.cpp
+  ${source_directory}/LibM.cpp
   ${source_directory}/Mapping.cpp
   ${source_directory}/Misc.cpp
   ${source_directory}/Parallelism.cpp
@@ -133,7 +135,7 @@ set(src_files
 # propagation. That said, we will run the vectorizer again after the runtime 
 # has been linked into the user program.
 set(clang_opt_flags -O3 -mllvm -openmp-opt-disable -DSHARED_SCRATCHPAD_SIZE=512 -mllvm -vectorize-slp=false )
-set(link_opt_flags  -O3        -openmp-opt-disable -attributor-enable=module -vectorize-slp=false )
+set(link_opt_flags  -O3        -openmp-opt-disable -vectorize-slp=false )
 set(link_export_flag -passes=internalize -internalize-public-api-file=${source_directory}/exports)
 
 # Prepend -I to each list element
@@ -143,9 +145,12 @@ list(TRANSFORM LIBOMPTARGET_LLVM_INCLUDE_DIRS_DEVICERTL PREPEND "-I")
 # Set flags for LLVM Bitcode compilation.
 set(bc_flags -c -foffload-lto -std=c++17 -fvisibility=hidden
               ${clang_opt_flags} --offload-device-only
-             -nocudalib -nogpulib -nostdinc
+             -nogpuinc -nogpulib
              -fopenmp -fopenmp-cuda-mode
              -Wno-unknown-cuda-version
+             -I${CMAKE_BINARY_DIR}/openmp/runtime/src # Need omp.h for LibM.
+             -I${CMAKE_BINARY_DIR}/projects/openmp/runtime/src # Need omp.h for LibM.
+             -I${CMAKE_BINARY_DIR}/runtime/src
              -DOMPTARGET_DEVICE_RUNTIME
              -I${include_directory}
              -I${devicertl_base_directory}/../include
@@ -158,82 +163,6 @@ else()
   list(APPEND bc_flags -DOMPTARGET_DEBUG=0)
 endif()
 
-function(addAMDSpecificBcLibs touch_target gfxname bc_files local_depend_files)
-  # For amdgpu, the libomptarget bc is "all inclusive".
-  # During user compilation, the libomptarget bc is essentially the only
-  # non-user library linked. It is linked once in GPU link phase
-  # following llvm-link options: --internalize --only-needed
-  if(NOT amd_device_libs_found)
-    find_package(AMDDeviceLibs REQUIRED CONFIG
-      HINTS
-      ${CMAKE_BINARY_DIR}/../../tools/rocm-device-libs
-      ${CMAKE_INSTALL_PREFIX}
-      PATHS
-      /opt/rocm)
-    if(AMDDeviceLibs_DIR)
-      set(amd_device_libs_found ON)
-      libomptarget_say("DeviceRTLs ${gfxname}: Getting ROCm device libs from ${AMDDeviceLibs_DIR}")
-    else()
-      libomptarget_say("DeviceRTLs ${gfxname}: Not building AMDGCN device RTL: Could not find AMDDeviceLibs package")
-      return()
-    endif()
-  endif()
-  get_target_property(ockl_bc_file ockl LOCATION)
-  get_target_property(ocml_bc_file ocml LOCATION)
-  set(amdgpu_wfsz_is32 gfx1030 gfx1031 gfx1032 gfx1033 gfx1034 gfx1035 gfx1036 gfx1100 gfx1101 gfx1102 gfx1103)
-  string(FIND "${amdgpu_wfsz_is32}" "${gfxname}" is_32bit)
-  if(NOT is_32bit EQUAL -1)
-    get_target_property(oclc_wf_bc_file oclc_wavefrontsize64_off LOCATION)
-  else()
-    get_target_property(oclc_wf_bc_file oclc_wavefrontsize64_on LOCATION)
-  endif()
-  string(LENGTH "${gfxname}" gfxlen)
-  if(gfxlen EQUAL 6)
-    string(SUBSTRING ${gfxname} 3 3 gfxnum)
-  else()
-    string(SUBSTRING ${gfxname} 3 4 gfxnum)
-  endif()
-  get_target_property(oclc_isa_bc_file oclc_isa_version_${gfxnum} LOCATION)
-
-  # Add custom target so targets from other directories
-  # can be added as dependencies to ensure libm
-  # and libhostexec bc files have been built.
-  add_custom_target(${touch_target} ALL)
-  add_dependencies(${touch_target}
-    libm-target-${gfxname}
-    libhostexec-${gfxname}.bc
-  )
-
-  # TODO: Add back -amdgpu to the names below (maybe?).
-  list(APPEND bc_files
-    ${CMAKE_BINARY_DIR}/libm-${gfxname}.bc
-  #  ${CMAKE_BINARY_DIR}/openmp/libomptarget/hostexec/libhostexec-${gfxname}.bc
-  )
-  if(OPENMP_STANDALONE_BUILD)
-    list(APPEND bc_files
-      ${CMAKE_BINARY_DIR}/libomptarget/hostexec/libhostexec-${gfxname}.bc
-    )
-  else()
-    list(APPEND bc_files
-      ${CMAKE_BINARY_DIR}/openmp/libomptarget/hostexec/libhostexec-${gfxname}.bc
-    )
-  endif()
-  if (EXISTS ${CMAKE_BINARY_DIR}/../../tools/ROCMDEVLIBS)
-    add_dependencies(${touch_target}
-      ockl ocml oclc_wavefrontsize64_on oclc_wavefrontsize64_off oclc_isa_version_${gfxnum})
-  endif()
-
-  # Add amdgcn-specific bc files to link command
-  list(APPEND bc_files ${ocml_bc_file} ${ockl_bc_file} ${oclc_wf_bc_file} ${oclc_isa_bc_file})
-
-  # Add touch-target-$(target_cpu) to local_depend_files so all $bc_files will exist or be created.
-  list(APPEND local_depend_files ${touch_target})
-
-  # Update these values in the caller:
-  set (bc_files ${bc_files} PARENT_SCOPE)
-  set (local_depend_files ${local_depend_files} PARENT_SCOPE)
-endfunction()
-
 # first create an object target
 add_library(omptarget.devicertl.all_objs OBJECT IMPORTED)
 function(compileDeviceRTLLibrary target_cpu target_name target_triple)
@@ -257,6 +186,20 @@ function(compileDeviceRTLLibrary target_cpu target_name target_triple)
       COMMENT "Building LLVM bitcode ${outfile}"
       VERBATIM
     )
+
+    if(${outfile} MATCHES "State.cpp")
+      # Run the prep tool on the library to replace internal attribute with linkonce_odr for dm_alloc only.
+      set(outfile_prep "${outfile}-${target_cpu}-prep.bc")
+      add_custom_target(${outfile_prep}
+          COMMAND ${PREP_TOOL} -dm ${outfile}
+                          -o ${outfile_prep}
+          DEPENDS ${outfile}
+          COMMENT "Running ${PREP_TOOL} for ${outfile_prep}"
+      )
+      add_dependencies(${outfile_prep} ${outfile})
+      set(outfile ${outfile_prep})
+    endif()
+
     if("${CLANG_TOOL}" STREQUAL "$<TARGET_FILE:clang>")
       # Add a file-level dependency to ensure that clang is up-to-date.
       # By default, add_custom_command only builds clang if the
@@ -268,21 +211,34 @@ function(compileDeviceRTLLibrary target_cpu target_name target_triple)
     list(APPEND bc_files ${outfile})
   endforeach()
 
-  set(bclib_name "libomptarget-${target_name}-${target_cpu}.bc")
-
-  set(local_depend_files ${bc_files})
-  if( ${target_name} STREQUAL "amdgpu" )
-    addAMDSpecificBcLibs("touch-target-${target_cpu}" ${target_cpu} "${bc_files}" "${local_depend_files}")
+  # Link in the previously compiled 'hostexec' bitcode directly.
+  if("${target_name}" STREQUAL "amdgpu")
+    if(OPENMP_STANDALONE_BUILD)
+      list(APPEND extra_bc_files
+        ${CMAKE_BINARY_DIR}/libomptarget/hostexec/libhostexec-${target_cpu}.bc
+      )
+    else()
+      list(APPEND extra_bc_files
+        ${CMAKE_BINARY_DIR}/openmp/libomptarget/hostexec/libhostexec-${target_cpu}.bc
+      )
+    endif()
+    add_custom_target(libhostexec-${target_cpu}
+      DEPENDS ${extra_bc_files}
+    )
+    add_dependencies(libhostexec-${target_cpu} libhostexec-${target_cpu}.bc)
+    set(extra_depends libhostexec-${target_cpu})
   endif()
 
+  set(bclib_name "libomptarget-${target_name}-${target_cpu}.bc")
+
   # Link to a bitcode library.
   add_custom_target(linked_${bclib_name}
       COMMAND ${LINK_TOOL}
-        -o ${CMAKE_CURRENT_BINARY_DIR}/linked_${bclib_name} ${bc_files}
-      DEPENDS ${bc_files}
+        -o ${CMAKE_CURRENT_BINARY_DIR}/linked_${bclib_name} ${extra_bc_files} ${bc_files}
+      DEPENDS ${bc_files} ${extra_depends}
       COMMENT "Linking LLVM bitcode ${bclib_name}"
   )
-  add_dependencies(linked_${bclib_name} ${local_depend_files})
+  add_dependencies(linked_${bclib_name} ${bc_files} ${extra_depends})
   if("${LINK_TOOL}" STREQUAL "$<TARGET_FILE:llvm-link>")
     add_dependencies(linked_${bclib_name} llvm-link)
   endif()
@@ -411,8 +367,24 @@ add_custom_target(omptarget.devicertl.nvptx)
 add_custom_target(omptarget.devicertl.amdgpu)
 foreach(gpu_arch ${LIBOMPTARGET_DEVICE_ARCHITECTURES})
   if("${gpu_arch}" IN_LIST all_amdgpu_architectures)
-    set(clang_options -DLIBOMPTARGET_BC_TARGET -fopenmp-targets=amdgcn-amd-amdhsa -Xopenmp-target=amdgcn-amd-amdhsa -march=${gpu_arch} -DLIBOMPTARGET_BC_TARGET -D__AMDGCN__ -nogpulib)
-    compileDeviceRTLLibrary(${gpu_arch} amdgpu amdgcn-amd-amdhsa -Xclang -mcode-object-version=none ${clang_options})
+    find_package(AMDDeviceLibs REQUIRED CONFIG
+                 HINTS ${CMAKE_INSTALL_PREFIX} 
+                       ${CMAKE_BINARY_DIR}/../../tools/rocm-device-libs
+                 PATHS /opt/rocm
+    )
+    
+    # Link in the ROCm Device Libraries once the other files have been linked.
+    get_target_property(ocml_path ocml IMPORTED_LOCATION)
+    get_target_property(ockl_path ockl IMPORTED_LOCATION)
+
+    set(amd_options -Xclang -mcode-object-version=none
+                    -Xclang -mlink-builtin-bitcode -Xclang ${ocml_path}
+                    -Xclang -mlink-builtin-bitcode -Xclang ${ockl_path}
+                    -Wno-linker-warnings # Silence the empty host compilation.
+                    -Xclang -mcode-object-version=none
+    )
+
+    compileDeviceRTLLibrary(${gpu_arch} amdgpu amdgcn-amd-amdhsa ${amd_options})
   elseif("${gpu_arch}" IN_LIST all_nvptx_architectures)
     compileDeviceRTLLibrary(${gpu_arch} nvptx nvptx64-nvidia-cuda --cuda-feature=+ptx61)
   else()

openmp/libomptarget/DeviceRTL/include/Debug.h

@@ -43,7 +43,6 @@ void __assert_fail_internal(const char *expr, const char *msg, const char *file,
 
 #define PRINTF(fmt, ...) (void)printf(fmt, ##__VA_ARGS__);
 #define PRINT(str) PRINTF("%s", str)
-
 ///}
 
 #endif

openmp/libomptarget/DeviceRTL/include/DevRTLExtras.h

@@ -79,13 +79,6 @@ typedef struct {
   uintptr_t value;
 } omp_alloctrait_t;
 
-// Attribute to keep alive certain definition for the bitcode library.
-#ifdef LIBOMPTARGET_BC_TARGET
-#define KEEP_ALIVE __attribute__((used, retain))
-#else
-#define KEEP_ALIVE
-#endif
-
 ///}
 
 #endif // OPENMP_LIBOMPTARGET_DEVICERTL_INCLUDE_DEVRTLEXTRAS_H