[Libomptarget] Replace use of `dlopen` with LLVM's dynamic library support

[jhuber6]

Summary

This patch replaces uses of dlopen and dlsym with LLVM's support
with loadPermanentLibrary and getSymbolAddress. This allows us to
remove the explicit dependency on the dl libraries in the CMake. This
removes another explicit dependency and solves an issue encountered
while building on Windows platforms. The one downside to this is that
the LLVM library does not currently support dlclose functionality, but
this could be added in the future.

[jhuber6]

Rebasing on D131516 which simplified the use of dlopen so this patch can easily replace it.

[jhuber6]

Remove use of last dlfcn header.

[jhuber6]

Fix duplicated header.

openmp/libomptarget/include/rtl.h

 //===------------ rtl.h - Target independent OpenMP target RTL ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Declarations for handling RTL plugins.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _OMPTARGET_RTL_H
 #define _OMPTARGET_RTL_H
 
-#include "omptarget.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/DynamicLibrary.h"
+
+#include "omptarget.h"
 
 #include <list>
 #include <map>
 #include <mutex>
 #include <string>
 
 // Forward declarations.
 struct DeviceTy;
typedef int64_t(init_device_into_ty)(int64_t, __tgt_device_info *,
                                        const char **);
 
   int32_t Idx = -1;             // RTL index, index is the number of devices
                                 // of other RTLs that were registered before,
                                 // i.e. the OpenMP index of the first device
                                 // to be registered with this RTL.
   int32_t NumberOfDevices = -1; // Number of devices this RTL deals with.
 
-  void *LibraryHandler = nullptr;
+  std::unique_ptr<llvm::sys::DynamicLibrary> LibraryHandler;
 
 #ifdef OMPTARGET_DEBUG
   std::string RTLName;
 #endif
 
   // Functions implemented in the RTL.
   init_plugin_ty *init_plugin = nullptr;
   deinit_plugin_ty *deinit_plugin = nullptr;

openmp/libomptarget/plugins/CMakeLists.txt

if(LIBOMPTARGET_DEP_LIBFFI_FOUND)
         ${LIBOMPTARGET_DEP_LIBFFI_INCLUDE_DIR}
         ${LIBOMPTARGET_DEP_LIBELF_INCLUDE_DIR}
 
         LINK_LIBS 
         PRIVATE
         elf_common
         ${LIBOMPTARGET_DEP_LIBFFI_LIBRARIES}
         ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
-        dl
         ${OPENMP_PTHREAD_LIB}
         "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports"
 
         NO_INSTALL_RPATH
       )
 
       # Install plugin under the lib destination folder.
       install(TARGETS "omptarget.rtl.${tmachine_libname}"

openmp/libomptarget/plugins/amdgpu/CMakeLists.txt

add_llvm_library(omptarget.rtl.amdgpu SHARED
   ADDITIONAL_HEADER_DIRS
   ${LIBOMPTARGET_INCLUDE_DIR}
   ${CMAKE_CURRENT_SOURCE_DIR}/impl
 
   LINK_LIBS 
   PRIVATE
   elf_common
   ${LIBOMPTARGET_DEP_LIBRARIES}
-  ${CMAKE_DL_LIBS}
   ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
   ${OPENMP_PTHREAD_LIB}
   "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports"
   ${LDFLAGS_UNDEFINED}
 
   NO_INSTALL_RPATH
 )
 add_dependencies(omptarget.rtl.amdgpu omptarget.devicertl.amdgpu)

openmp/libomptarget/plugins/amdgpu/dynamic_hsa/hsa.cpp

 //===--- amdgpu/dynamic_hsa/hsa.cpp ------------------------------- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement subset of hsa api by calling into hsa library via dlopen
 // Does the dlopen/dlsym calls as part of the call to hsa_init
 //
 //===----------------------------------------------------------------------===//
-#include "hsa.h"
+
+#include "llvm/Support/DynamicLibrary.h"
+
 #include "Debug.h"
 #include "dlwrap.h"
+#include "hsa.h"
 #include "hsa_ext_amd.h"
-
-#include <dlfcn.h>
+#include <memory>
 
 DLWRAP_INITIALIZE();
 
 DLWRAP_INTERNAL(hsa_init, 0);
 
 DLWRAP(hsa_status_string, 2);
 DLWRAP(hsa_shut_down, 0);
 DLWRAP(hsa_system_get_info, 2);

 #error "Missing TARGET_NAME macro"
 #endif
 #define DEBUG_PREFIX "Target " GETNAME(TARGET_NAME) " RTL"
 
 static bool checkForHSA() {
   // return true if dlopen succeeded and all functions found
 
   const char *HsaLib = DYNAMIC_HSA_PATH;
-  void *DynlibHandle = dlopen(HsaLib, RTLD_NOW);
-  if (!DynlibHandle) {
-    DP("Unable to load library '%s': %s!\n", HsaLib, dlerror());
+  std::string ErrMsg;
+  auto DynlibHandle = std::make_unique<llvm::sys::DynamicLibrary>(
+      llvm::sys::DynamicLibrary::getPermanentLibrary(HsaLib, &ErrMsg));
+  if (!DynlibHandle->isValid()) {
+    DP("Unable to load library '%s': %s!\n", HsaLib, ErrMsg.c_str());
     return false;
   }
 
   for (size_t I = 0; I < dlwrap::size(); I++) {
     const char *Sym = dlwrap::symbol(I);
 
-    void *P = dlsym(DynlibHandle, Sym);
+    void *P = DynlibHandle->getAddressOfSymbol(Sym);
     if (P == nullptr) {
       DP("Unable to find '%s' in '%s'!\n", Sym, HsaLib);
       return false;
     }
     DP("Implementing %s with dlsym(%s) -> %p\n", Sym, Sym, P);
 
     *dlwrap::pointer(I) = P;
   }

openmp/libomptarget/plugins/cuda/CMakeLists.txt

add_llvm_library(omptarget.rtl.cuda
     ADDITIONAL_HEADER_DIRS
     ${LIBOMPTARGET_INCLUDE_DIR}
     ${LIBOMPTARGET_DEP_LIBELF_INCLUDE_DIRS}
 
     LINK_LIBS
     PRIVATE
     elf_common
     MemoryManager
-    ${CMAKE_DL_LIBS}
     ${LIBOMPTARGET_DEP_LIBELF_LIBRARIES}
     ${OPENMP_PTHREAD_LIB}
     "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/../exports"
     "-Wl,-z,defs"
 
     NO_INSTALL_RPATH
   )
 endif()

openmp/libomptarget/plugins/cuda/dynamic_cuda/cuda.cpp

 //===--- cuda/dynamic_cuda/cuda.pp ------------------------------- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Implement subset of cuda api by calling into cuda library via dlopen
 // Does the dlopen/dlsym calls as part of the call to cuInit
 //
 //===----------------------------------------------------------------------===//
 
-#include "cuda.h"
+#include "llvm/Support/DynamicLibrary.h"
+
 #include "Debug.h"
+#include "cuda.h"
 #include "dlwrap.h"
 
+#include <memory>
 #include <string>
 #include <unordered_map>
 
-#include <dlfcn.h>
-
 DLWRAP_INITIALIZE();
 
 DLWRAP_INTERNAL(cuInit, 1);
 
 DLWRAP(cuCtxGetDevice, 1);
 DLWRAP(cuDeviceGet, 2);
 DLWRAP(cuDeviceGetAttribute, 3);
 DLWRAP(cuDeviceGetCount, 1);
std::unordered_map<std::string, const char *> TryFirst = {
       {"cuMemcpyDtoHAsync", "cuMemcpyDtoHAsync_v2"},
       {"cuMemcpyDtoDAsync", "cuMemcpyDtoDAsync_v2"},
       {"cuMemcpyHtoDAsync", "cuMemcpyHtoDAsync_v2"},
       {"cuDevicePrimaryCtxRelease", "cuDevicePrimaryCtxRelease_v2"},
       {"cuDevicePrimaryCtxSetFlags", "cuDevicePrimaryCtxSetFlags_v2"},
   };
 
   const char *CudaLib = DYNAMIC_CUDA_PATH;
-  void *DynlibHandle = dlopen(CudaLib, RTLD_NOW);
-  if (!DynlibHandle) {
-    DP("Unable to load library '%s': %s!\n", CudaLib, dlerror());
+  std::string ErrMsg;
+  auto DynlibHandle = std::make_unique<llvm::sys::DynamicLibrary>(
+      llvm::sys::DynamicLibrary::getPermanentLibrary(CudaLib, &ErrMsg));
+  if (!DynlibHandle->isValid()) {
+    DP("Unable to load library '%s': %s!\n", CudaLib, ErrMsg.c_str());
     return false;
   }
 
   for (size_t I = 0; I < dlwrap::size(); I++) {
     const char *Sym = dlwrap::symbol(I);
 
     auto It = TryFirst.find(Sym);
     if (It != TryFirst.end()) {
       const char *First = It->second;
-      void *P = dlsym(DynlibHandle, First);
+      void *P = DynlibHandle->getAddressOfSymbol(First);
       if (P) {
         DP("Implementing %s with dlsym(%s) -> %p\n", Sym, First, P);
         *dlwrap::pointer(I) = P;
         continue;
       }
     }
 
-    void *P = dlsym(DynlibHandle, Sym);
+    void *P = DynlibHandle->getAddressOfSymbol(Sym);
     if (P == nullptr) {
       DP("Unable to find '%s' in '%s'!\n", Sym, CudaLib);
       return false;
     }
     DP("Implementing %s with dlsym(%s) -> %p\n", Sym, Sym, P);
 
     *dlwrap::pointer(I) = P;
   }

openmp/libomptarget/plugins/generic-elf-64bit/src/rtl.cpp

 //===-RTLs/generic-64bit/src/rtl.cpp - Target RTLs Implementation - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RTL for generic 64-bit machine
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/DynamicLibrary.h"
 
 #include <cassert>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <dlfcn.h>
 #include <ffi.h>
 #include <gelf.h>
 #include <link.h>
 #include <list>
 #include <string>
 #include <vector>
 
 #include "Debug.h"
 #include "omptargetplugin.h"
 
 using namespace llvm;
+using namespace llvm::sys;
 
 #ifndef TARGET_NAME
 #define TARGET_NAME Generic ELF - 64bit
 #endif
 #define DEBUG_PREFIX "TARGET " GETNAME(TARGET_NAME) " RTL"
 
 #ifndef TARGET_ELF_ID
 #define TARGET_ELF_ID 0
 #endif
 
 #include "elf_common.h"
 
 #define NUMBER_OF_DEVICES 4
 #define OFFLOADSECTIONNAME "omp_offloading_entries"
 
 /// Array of Dynamic libraries loaded for this target.
 struct DynLibTy {
   std::string FileName;
-  void *Handle;
+  std::unique_ptr<DynamicLibrary> DynLib;
 };
 
 /// Keep entries table per device.
 struct FuncOrGblEntryTy {
   __tgt_target_table Table;
   SmallVector<__tgt_offload_entry> Entries;
 };
 
__tgt_target_table *getOffloadEntriesTable(int32_t DeviceId) {
     return &E.Table;
   }
 
   RTLDeviceInfoTy(int32_t NumDevices) { FuncGblEntries.resize(NumDevices); }
 
   ~RTLDeviceInfoTy() {
     // Close dynamic libraries
     for (auto &Lib : DynLibs) {
-      if (Lib.Handle) {
-        dlclose(Lib.Handle);
+      if (Lib.DynLib->isValid())
         remove(Lib.FileName.c_str());
-      }
-    }
-  }
 };
 
 static RTLDeviceInfoTy DeviceInfo(NUMBER_OF_DEVICES);
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
__tgt_target_table *__tgt_rtl_load_binary(int32_t DeviceId,
   FILE *Ftmp = fdopen(TmpFd, "wb");
 
   if (!Ftmp)
     return nullptr;
 
   fwrite(Image->ImageStart, ImageSize, 1, Ftmp);
   fclose(Ftmp);
 
-  DynLibTy Lib = {TmpName, dlopen(TmpName, RTLD_LAZY)};
+  std::string ErrMsg;
+  auto DynLib = std::make_unique<sys::DynamicLibrary>(
+      sys::DynamicLibrary::getPermanentLibrary(TmpName, &ErrMsg));
+  DynLibTy Lib = {TmpName, std::move(DynLib)};
 
-  if (!Lib.Handle) {
-    DP("Target library loading error: %s\n", dlerror());
+  if (!Lib.DynLib->isValid()) {
+    DP("Target library loading error: %s\n", ErrMsg.c_str());
     return NULL;
   }
 
-  DeviceInfo.DynLibs.push_back(Lib);
-
   __tgt_offload_entry *HostBegin = Image->EntriesBegin;
   __tgt_offload_entry *HostEnd = Image->EntriesEnd;
 
   // Create a new offloading entry list using the device symbol address.
   SmallVector<__tgt_offload_entry> Entries;
   for (__tgt_offload_entry *E = HostBegin; E != HostEnd; ++E) {
     if (!E->addr)
       return nullptr;
 
     __tgt_offload_entry Entry = *E;
 
-    void *DevAddr = dlsym(Lib.Handle, E->name);
+    void *DevAddr = Lib.DynLib->getAddressOfSymbol(E->name);
     Entry.addr = DevAddr;
 
     DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
        DPxPTR(E - HostBegin), E->name, DPxPTR(DevAddr));
 
     Entries.emplace_back(Entry);
   }
 
   DeviceInfo.createOffloadTable(DeviceId, std::move(Entries));
+  DeviceInfo.DynLibs.emplace_back(std::move(Lib));
 
   return DeviceInfo.getOffloadEntriesTable(DeviceId);
 }
 
 void __tgt_rtl_print_device_info(int32_t DeviceId) {
   printf("    This is a generic-elf-64bit device\n");
 }
 

openmp/libomptarget/src/CMakeLists.txt

add_llvm_library(omptarget
   ${LIBOMPTARGET_INCLUDE_DIR}
 
   LINK_COMPONENTS
   Support
   Object
 
   LINK_LIBS 
   PRIVATE
-  ${CMAKE_DL_LIBS}
   "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/exports"
   NO_INSTALL_RPATH
 )
 target_include_directories(omptarget PRIVATE ${LIBOMPTARGET_INCLUDE_DIR})
 
 # libomptarget.so needs to be aware of where the plugins live as they
 # are now separated in the build directory.
 set_target_properties(omptarget PROPERTIES INSTALL_RPATH "$ORIGIN" BUILD_RPATH "$ORIGIN:${CMAKE_CURRENT_BINARY_DIR}/..")
 install(TARGETS omptarget LIBRARY COMPONENT omptarget DESTINATION "${OPENMP_INSTALL_LIBDIR}")

openmp/libomptarget/src/rtl.cpp

 //===----------- rtl.cpp - Target independent OpenMP target RTL -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Functionality for handling RTL plugins.
 //
 //===----------------------------------------------------------------------===//
 
-#include "rtl.h"
+#include "llvm/Object/OffloadBinary.h"
+
 #include "device.h"
 #include "private.h"
-
-#include "llvm/Object/OffloadBinary.h"
+#include "rtl.h"
 
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
-#include <dlfcn.h>
 #include <mutex>
 #include <string>
 
+using namespace llvm;
+using namespace llvm::sys;
+
 // List of all plugins that can support offloading.
 static const char *RTLNames[] = {
     /* PowerPC target       */ "libomptarget.rtl.ppc64.so",
     /* x86_64 target        */ "libomptarget.rtl.x86_64.so",
     /* CUDA target          */ "libomptarget.rtl.cuda.so",
     /* AArch64 target       */ "libomptarget.rtl.aarch64.so",
     /* SX-Aurora VE target  */ "libomptarget.rtl.ve.so",
     /* AMDGPU target        */ "libomptarget.rtl.amdgpu.so",
__attribute__((constructor(101))) void init() {
   }
 
   PM = new PluginManager(UseEventsForAtomicTransfers);
 
 #ifdef OMPTARGET_PROFILE_ENABLED
   ProfileTraceFile = getenv("LIBOMPTARGET_PROFILE");
   // TODO: add a configuration option for time granularity
   if (ProfileTraceFile)
-    llvm::timeTraceProfilerInitialize(500 /* us */, "libomptarget");
+    timeTraceProfilerInitialize(500 /* us */, "libomptarget");
 #endif
 }
 
 __attribute__((destructor(101))) void deinit() {
   DP("Deinit target library!\n");
 
   for (auto *R : PM->RTLs.UsedRTLs) {
     // Plugins can either destroy their local state using global variables
for (auto *R : PM->RTLs.UsedRTLs) {
     }
   }
 
   delete PM;
 
 #ifdef OMPTARGET_PROFILE_ENABLED
   if (ProfileTraceFile) {
     // TODO: add env var for file output
-    if (auto E = llvm::timeTraceProfilerWrite(ProfileTraceFile, "-"))
+    if (auto E = timeTraceProfilerWrite(ProfileTraceFile, "-"))
       fprintf(stderr, "Error writing out the time trace\n");
 
-    llvm::timeTraceProfilerCleanup();
+    timeTraceProfilerCleanup();
   }
 #endif
 }
 
 void RTLsTy::loadRTLs() {
   // Parse environment variable OMP_TARGET_OFFLOAD (if set)
   PM->TargetOffloadPolicy =
       (kmp_target_offload_kind_t)__kmpc_get_target_offload();
   if (PM->TargetOffloadPolicy == tgt_disabled) {
     return;
   }
 
   DP("Loading RTLs...\n");
 
   // Attempt to open all the plugins and, if they exist, check if the interface
   // is correct and if they are supporting any devices.
   for (auto *Name : RTLNames) {
     DP("Loading library '%s'...\n", Name);
-    void *DynlibHandle = dlopen(Name, RTLD_NOW);
+    std::string ErrMsg;
+    auto DynLibrary = std::make_unique<sys::DynamicLibrary>(
+        sys::DynamicLibrary::getPermanentLibrary(Name, &ErrMsg));
 
-    if (!DynlibHandle) {
+    if (!DynLibrary->isValid()) {
       // Library does not exist or cannot be found.
-      DP("Unable to load library '%s': %s!\n", Name, dlerror());
+      DP("Unable to load library '%s': %s!\n", Name, ErrMsg.c_str());
       continue;
     }
 
     DP("Successfully loaded library '%s'!\n", Name);
 
     AllRTLs.emplace_back();
 
     // Retrieve the RTL information from the runtime library.
     RTLInfoTy &R = AllRTLs.back();
 
     // Remove plugin on failure to call optional init_plugin
-    *((void **)&R.init_plugin) = dlsym(DynlibHandle, "__tgt_rtl_init_plugin");
+    *((void **)&R.init_plugin) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_init_plugin");
     if (R.init_plugin) {
       int32_t Rc = R.init_plugin();
       if (Rc != OFFLOAD_SUCCESS) {
         DP("Unable to initialize library '%s': %u!\n", Name, Rc);
         AllRTLs.pop_back();
         continue;
       }
     }
 
     bool ValidPlugin = true;
 
     if (!(*((void **)&R.is_valid_binary) =
-              dlsym(DynlibHandle, "__tgt_rtl_is_valid_binary")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_is_valid_binary")))
       ValidPlugin = false;
     if (!(*((void **)&R.number_of_devices) =
-              dlsym(DynlibHandle, "__tgt_rtl_number_of_devices")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_number_of_devices")))
       ValidPlugin = false;
     if (!(*((void **)&R.init_device) =
-              dlsym(DynlibHandle, "__tgt_rtl_init_device")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_init_device")))
       ValidPlugin = false;
     if (!(*((void **)&R.load_binary) =
-              dlsym(DynlibHandle, "__tgt_rtl_load_binary")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_load_binary")))
       ValidPlugin = false;
     if (!(*((void **)&R.data_alloc) =
-              dlsym(DynlibHandle, "__tgt_rtl_data_alloc")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_data_alloc")))
       ValidPlugin = false;
     if (!(*((void **)&R.data_submit) =
-              dlsym(DynlibHandle, "__tgt_rtl_data_submit")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_data_submit")))
       ValidPlugin = false;
     if (!(*((void **)&R.data_retrieve) =
-              dlsym(DynlibHandle, "__tgt_rtl_data_retrieve")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_data_retrieve")))
       ValidPlugin = false;
     if (!(*((void **)&R.data_delete) =
-              dlsym(DynlibHandle, "__tgt_rtl_data_delete")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_data_delete")))
       ValidPlugin = false;
     if (!(*((void **)&R.run_region) =
-              dlsym(DynlibHandle, "__tgt_rtl_run_target_region")))
+              DynLibrary->getAddressOfSymbol("__tgt_rtl_run_target_region")))
       ValidPlugin = false;
-    if (!(*((void **)&R.run_team_region) =
-              dlsym(DynlibHandle, "__tgt_rtl_run_target_team_region")))
+    if (!(*((void **)&R.run_team_region) = DynLibrary->getAddressOfSymbol(
+              "__tgt_rtl_run_target_team_region")))
       ValidPlugin = false;
 
     // Invalid plugin
     if (!ValidPlugin) {
       DP("Invalid plugin as necessary interface is not found.\n");
       AllRTLs.pop_back();
       continue;
     }
 
     // No devices are supported by this RTL?
     if (!(R.NumberOfDevices = R.number_of_devices())) {
       // The RTL is invalid! Will pop the object from the RTLs list.
       DP("No devices supported in this RTL\n");
       AllRTLs.pop_back();
       continue;
     }
 
-    R.LibraryHandler = DynlibHandle;
-
 #ifdef OMPTARGET_DEBUG
     R.RTLName = Name;
 #endif
 
     DP("Registering RTL %s supporting %d devices!\n", R.RTLName.c_str(),
        R.NumberOfDevices);
 
     // Optional functions
     *((void **)&R.deinit_plugin) =
-        dlsym(DynlibHandle, "__tgt_rtl_deinit_plugin");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_deinit_plugin");
     *((void **)&R.is_valid_binary_info) =
-        dlsym(DynlibHandle, "__tgt_rtl_is_valid_binary_info");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_is_valid_binary_info");
     *((void **)&R.deinit_device) =
-        dlsym(DynlibHandle, "__tgt_rtl_deinit_device");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_deinit_device");
     *((void **)&R.init_requires) =
-        dlsym(DynlibHandle, "__tgt_rtl_init_requires");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_init_requires");
     *((void **)&R.data_submit_async) =
-        dlsym(DynlibHandle, "__tgt_rtl_data_submit_async");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_data_submit_async");
     *((void **)&R.data_retrieve_async) =
-        dlsym(DynlibHandle, "__tgt_rtl_data_retrieve_async");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_data_retrieve_async");
     *((void **)&R.run_region_async) =
-        dlsym(DynlibHandle, "__tgt_rtl_run_target_region_async");
-    *((void **)&R.run_team_region_async) =
-        dlsym(DynlibHandle, "__tgt_rtl_run_target_team_region_async");
-    *((void **)&R.synchronize) = dlsym(DynlibHandle, "__tgt_rtl_synchronize");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_run_target_region_async");
+    *((void **)&R.run_team_region_async) = DynLibrary->getAddressOfSymbol(
+        "__tgt_rtl_run_target_team_region_async");
+    *((void **)&R.synchronize) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_synchronize");
     *((void **)&R.data_exchange) =
-        dlsym(DynlibHandle, "__tgt_rtl_data_exchange");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_data_exchange");
     *((void **)&R.data_exchange_async) =
-        dlsym(DynlibHandle, "__tgt_rtl_data_exchange_async");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_data_exchange_async");
     *((void **)&R.is_data_exchangable) =
-        dlsym(DynlibHandle, "__tgt_rtl_is_data_exchangable");
-    *((void **)&R.register_lib) = dlsym(DynlibHandle, "__tgt_rtl_register_lib");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_is_data_exchangable");
+    *((void **)&R.register_lib) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_register_lib");
     *((void **)&R.unregister_lib) =
-        dlsym(DynlibHandle, "__tgt_rtl_unregister_lib");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_unregister_lib");
     *((void **)&R.supports_empty_images) =
-        dlsym(DynlibHandle, "__tgt_rtl_supports_empty_images");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_supports_empty_images");
     *((void **)&R.set_info_flag) =
-        dlsym(DynlibHandle, "__tgt_rtl_set_info_flag");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_set_info_flag");
     *((void **)&R.print_device_info) =
-        dlsym(DynlibHandle, "__tgt_rtl_print_device_info");
-    *((void **)&R.create_event) = dlsym(DynlibHandle, "__tgt_rtl_create_event");
-    *((void **)&R.record_event) = dlsym(DynlibHandle, "__tgt_rtl_record_event");
-    *((void **)&R.wait_event) = dlsym(DynlibHandle, "__tgt_rtl_wait_event");
-    *((void **)&R.sync_event) = dlsym(DynlibHandle, "__tgt_rtl_sync_event");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_print_device_info");
+    *((void **)&R.create_event) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_create_event");
+    *((void **)&R.record_event) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_record_event");
+    *((void **)&R.wait_event) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_wait_event");
+    *((void **)&R.sync_event) =
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_sync_event");
     *((void **)&R.destroy_event) =
-        dlsym(DynlibHandle, "__tgt_rtl_destroy_event");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_destroy_event");
     *((void **)&R.release_async_info) =
-        dlsym(DynlibHandle, "__tgt_rtl_release_async_info");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_release_async_info");
     *((void **)&R.init_async_info) =
-        dlsym(DynlibHandle, "__tgt_rtl_init_async_info");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_init_async_info");
     *((void **)&R.init_device_info) =
-        dlsym(DynlibHandle, "__tgt_rtl_init_device_info");
+        DynLibrary->getAddressOfSymbol("__tgt_rtl_init_device_info");
+
+    R.LibraryHandler = std::move(DynLibrary);
   }
 
   DP("RTLs loaded!\n");
 
   return;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
for (__tgt_offload_entry *Entry = Img->EntriesBegin;
         DP("The \"link\" attribute is not yet supported!\n");
       }
     }
     Device.PendingGlobalsMtx.unlock();
   }
 }
 
 static __tgt_device_image getExecutableImage(__tgt_device_image *Image) {
-  llvm::StringRef ImageStr(static_cast<char *>(Image->ImageStart),
-                           static_cast<char *>(Image->ImageEnd) -
-                               static_cast<char *>(Image->ImageStart));
+  StringRef ImageStr(static_cast<char *>(Image->ImageStart),
   auto BinaryOrErr =
-      llvm::object::OffloadBinary::create(llvm::MemoryBufferRef(ImageStr, ""));
+      object::OffloadBinary::create(MemoryBufferRef(ImageStr, ""));
   if (!BinaryOrErr) {
-    llvm::consumeError(BinaryOrErr.takeError());
+    consumeError(BinaryOrErr.takeError());
     return *Image;
   }
 
   void *Begin = const_cast<void *>(
       static_cast<const void *>((*BinaryOrErr)->getImage().bytes_begin()));
   void *End = const_cast<void *>(
       static_cast<const void *>((*BinaryOrErr)->getImage().bytes_end()));
 
   return {Begin, End, Image->EntriesBegin, Image->EntriesEnd};
 }
 
 static __tgt_image_info getImageInfo(__tgt_device_image *Image) {
-  llvm::StringRef ImageStr(static_cast<char *>(Image->ImageStart),
-                           static_cast<char *>(Image->ImageEnd) -
-                               static_cast<char *>(Image->ImageStart));
+  StringRef ImageStr(static_cast<char *>(Image->ImageStart),
   auto BinaryOrErr =
-      llvm::object::OffloadBinary::create(llvm::MemoryBufferRef(ImageStr, ""));
+      object::OffloadBinary::create(MemoryBufferRef(ImageStr, ""));
   if (!BinaryOrErr) {
-    llvm::consumeError(BinaryOrErr.takeError());
+    consumeError(BinaryOrErr.takeError());
     return __tgt_image_info{};
   }
 
   return __tgt_image_info{(*BinaryOrErr)->getArch().data()};
 }
 
 void RTLsTy::registerRequires(int64_t Flags) {
   // TODO: add more elaborate check.
if (!R.IsUsed && R.NumberOfDevices != 0) {
     R.Idx = (UsedRTLs.empty())
                 ? 0
                 : UsedRTLs.back()->Idx + UsedRTLs.back()->NumberOfDevices;
     assert((size_t)R.Idx == Start &&
            "RTL index should equal the number of devices used so far.");
     R.IsUsed = true;
     UsedRTLs.push_back(&R);
 
-    DP("RTL " DPxMOD " has index %d!\n", DPxPTR(R.LibraryHandler), R.Idx);
+    DP("RTL " DPxMOD " has index %d!\n", DPxPTR(R.LibraryHandler.get()), R.Idx);
   }
 }
 
 void RTLsTy::initAllRTLs() {
   for (auto &R : AllRTLs)
     initRTLonce(R);
 }
 
for (auto *R : UsedRTLs) {
         }
       } else if (!R->is_valid_binary(Img)) {
         DP("Image " DPxMOD " is NOT compatible with RTL %s!\n",
            DPxPTR(Img->ImageStart), R->RTLName.c_str());
         continue;
       }
 
       DP("Image " DPxMOD " is compatible with RTL " DPxMOD "!\n",
-         DPxPTR(Img->ImageStart), DPxPTR(R->LibraryHandler));
+         DPxPTR(Img->ImageStart), DPxPTR(R->LibraryHandler.get()));
 
       FoundRTL = R;
 
       // Execute dtors for static objects if the device has been used, i.e.
       // if its PendingCtors list has been emptied.
       for (int32_t I = 0; I < FoundRTL->NumberOfDevices; ++I) {
         DeviceTy &Device = *PM->Devices[FoundRTL->Idx + I];
         Device.PendingGlobalsMtx.lock();
for (auto *R : UsedRTLs) {
           // All constructors have been issued, wait for them now.
           if (AsyncInfo.synchronize() != OFFLOAD_SUCCESS)
             DP("Failed synchronizing destructors kernels.\n");
         }
         Device.PendingGlobalsMtx.unlock();
       }
 
       DP("Unregistered image " DPxMOD " from RTL " DPxMOD "!\n",
-         DPxPTR(Img->ImageStart), DPxPTR(R->LibraryHandler));
+         DPxPTR(Img->ImageStart), DPxPTR(R->LibraryHandler.get()));
 
       break;
     }
 
     // if no RTL was found proceed to unregister the next image
     if (!FoundRTL) {
       DP("No RTLs in use support the image " DPxMOD "!\n",
          DPxPTR(Img->ImageStart));