[Clang] Remove direct linking of offloading runtimes from the arch tools

[jhuber6]

Summary

The tools amdgpu-arch and nvptx-arch are used to query the supported
GPUs on a system to implement features like --offload-arch=native as
well as generally being useful for setting up tests. However, we
currently directly link these if they are availible. This patch removes
this because it causes many problems on the user not having the libaries
present or misconfigured at build time. Since these are built
unconditionally we shoudl keep the dependencies away from clang.

Fixes https://github.com/llvm/llvm-project/issues/62784

[jhuber6]

Remove now unused definitions

clang/tools/amdgpu-arch/AMDGPUArch.cpp

 
 // Mark all our options with this category.
 static cl::OptionCategory AMDGPUArchCategory("amdgpu-arch options");
 
 static void PrintVersion(raw_ostream &OS) {
   OS << clang::getClangToolFullVersion("amdgpu-arch") << '\n';
 }
 
-#if DYNAMIC_HSA
 typedef enum {
   HSA_STATUS_SUCCESS = 0x0,
 } hsa_status_t;
 
 typedef enum {
   HSA_DEVICE_TYPE_CPU = 0,
   HSA_DEVICE_TYPE_GPU = 1,
 } hsa_device_type_t;
#define DYNAMIC_INIT(SYMBOL)                                                   \
   }
   DYNAMIC_INIT(hsa_init);
   DYNAMIC_INIT(hsa_shut_down);
   DYNAMIC_INIT(hsa_agent_get_info);
   DYNAMIC_INIT(hsa_iterate_agents);
 #undef DYNAMIC_INIT
   return llvm::Error::success();
 }
-#else
-
-#if defined(__has_include)
-#if __has_include("hsa/hsa.h")
-#include "hsa/hsa.h"
-#elif __has_include("hsa.h")
-#include "hsa.h"
-#endif
-#endif
-
-llvm::Error loadHSA() { return llvm::Error::success(); }
-#endif
 
 static hsa_status_t iterateAgentsCallback(hsa_agent_t Agent, void *Data) {
   hsa_device_type_t DeviceType;
   hsa_status_t Status =
       hsa_agent_get_info(Agent, HSA_AGENT_INFO_DEVICE, &DeviceType);
 
   // continue only if device type if GPU
   if (Status != HSA_STATUS_SUCCESS || DeviceType != HSA_DEVICE_TYPE_GPU) {

clang/tools/amdgpu-arch/CMakeLists.txt

 # //===----------------------------------------------------------------------===//
 # //
 # // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # // See https://llvm.org/LICENSE.txt for details.
 # // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # //
 # //===----------------------------------------------------------------------===//
 
 set(LLVM_LINK_COMPONENTS Support)
 
 add_clang_tool(amdgpu-arch AMDGPUArch.cpp)
 
-# If we find the HSA runtime we link with it directly.
-find_package(hsa-runtime64 QUIET 1.2.0 HINTS ${CMAKE_INSTALL_PREFIX} PATHS /opt/rocm)
-if(hsa-runtime64_FOUND AND NOT (LLVM_BUILD_32_BITS OR CMAKE_SIZEOF_VOID_P EQUAL 4))
-  set_target_properties(amdgpu-arch PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
-  target_link_libraries(amdgpu-arch PRIVATE hsa-runtime64::hsa-runtime64 clangBasic)
-else()
-  target_compile_definitions(amdgpu-arch PRIVATE "DYNAMIC_HSA")
-  target_link_libraries(amdgpu-arch PRIVATE clangBasic)
-endif()

clang/tools/nvptx-arch/CMakeLists.txt

 # //===--------------------------------------------------------------------===//
 # //
 # // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # // See https://llvm.org/LICENSE.txt for details.
 # // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 # //
 # //===--------------------------------------------------------------------===//
 
 set(LLVM_LINK_COMPONENTS Support)
 add_clang_tool(nvptx-arch NVPTXArch.cpp)
 
-find_package(CUDAToolkit QUIET)
-
-# If we found the CUDA library directly we just dynamically link against it.
-if(CUDAToolkit_FOUND AND NOT (LLVM_BUILD_32_BITS OR CMAKE_SIZEOF_VOID_P EQUAL 4))
-  target_link_libraries(nvptx-arch PRIVATE CUDA::cuda_driver clangBasic)
-else()
-  target_compile_definitions(nvptx-arch PRIVATE "DYNAMIC_CUDA")
-  target_link_libraries(nvptx-arch PRIVATE clangBasic)
-endif()

clang/tools/nvptx-arch/NVPTXArch.cpp

 
 static void PrintVersion(raw_ostream &OS) {
   OS << clang::getClangToolFullVersion("nvptx-arch") << '\n';
 }
 // Mark all our options with this category, everything else (except for -version
 // and -help) will be hidden.
 static cl::OptionCategory NVPTXArchCategory("nvptx-arch options");
 
-#if DYNAMIC_CUDA
 typedef enum cudaError_enum {
   CUDA_SUCCESS = 0,
   CUDA_ERROR_NO_DEVICE = 100,
 } CUresult;
 
 typedef enum CUdevice_attribute_enum {
   CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = 75,
   CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = 76,
#define DYNAMIC_INIT(SYMBOL)                                                   \
   DYNAMIC_INIT(cuInit);
   DYNAMIC_INIT(cuDeviceGetCount);
   DYNAMIC_INIT(cuGetErrorString);
   DYNAMIC_INIT(cuDeviceGet);
   DYNAMIC_INIT(cuDeviceGetAttribute);
 #undef DYNAMIC_INIT
   return llvm::Error::success();
 }
-#else
-
-#include "cuda.h"
-llvm::Error loadCUDA() { return llvm::Error::success(); }
-
-#endif
 
 static int handleError(CUresult Err) {
   const char *ErrStr = nullptr;
   CUresult Result = cuGetErrorString(Err, &ErrStr);
   if (Result != CUDA_SUCCESS)
     return 1;
   fprintf(stderr, "CUDA error: %s\n", ErrStr);
   return 1;