[Libomptarget] Remove use of ELF link_address in x86_64 plugin

[jhuber6]

Summary

We use the offloading entires array to determine the relative names and
addressed of device-side kernel functions. The x86_64 plugin previously
derived the device-side entry table by first identifying the
omp_offloading_entries section offset in the loaded elf. Then we would
use the base offset of the loaded dyanmic library to identify the
entries array within the loaded image. This relied on some more
unconventional methods which prevented us from using the LLVM dynamic
library loader for this plugin. This patch simplifies this by instead
copying the host-side entry and replacing its address with the
device-side address looked up through dlsym.

[JonChesterfield]

Nice, thanks!

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 <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;
+
 #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;
 };
 
 /// Keep entries table per device.
 struct FuncOrGblEntryTy {
   __tgt_target_table Table;
+  SmallVector<__tgt_offload_entry> Entries;
 };
 
 /// Class containing all the device information.
 class RTLDeviceInfoTy {
   std::vector<std::list<FuncOrGblEntryTy>> FuncGblEntries;
 
 public:
   std::list<DynLibTy> DynLibs;
 
   // Record entry point associated with device.
-  void createOffloadTable(int32_t DeviceId, __tgt_offload_entry *Begin,
-                          __tgt_offload_entry *End) {
+  void createOffloadTable(int32_t DeviceId,
+                          SmallVector<__tgt_offload_entry> &&Entries) {
     assert(DeviceId < (int32_t)FuncGblEntries.size() &&
            "Unexpected device id!");
     FuncGblEntries[DeviceId].emplace_back();
     FuncOrGblEntryTy &E = FuncGblEntries[DeviceId].back();
 
-    E.Table.EntriesBegin = Begin;
-    E.Table.EntriesEnd = End;
+    E.Entries = Entries;
+    E.Table.EntriesBegin = E.Entries.begin();
+    E.Table.EntriesEnd = E.Entries.end();
   }
 
   // Return true if the entry is associated with device.
   bool findOffloadEntry(int32_t DeviceId, void *Addr) {
     assert(DeviceId < (int32_t)FuncGblEntries.size() &&
            "Unexpected device id!");
     FuncOrGblEntryTy &E = FuncGblEntries[DeviceId].back();
 
DP("Dev %d: load binary from " DPxMOD " image\n", DeviceId,
      DPxPTR(Image->ImageStart));
 
   assert(DeviceId >= 0 && DeviceId < NUMBER_OF_DEVICES && "bad dev id");
 
   size_t ImageSize = (size_t)Image->ImageEnd - (size_t)Image->ImageStart;
   size_t NumEntries = (size_t)(Image->EntriesEnd - Image->EntriesBegin);
   DP("Expecting to have %zd entries defined.\n", NumEntries);
 
-  // Is the library version incompatible with the header file?
-  if (elf_version(EV_CURRENT) == EV_NONE) {
-    DP("Incompatible ELF library!\n");
-    return NULL;
-  }
-
-  // Obtain elf handler
-  Elf *E = elf_memory((char *)Image->ImageStart, ImageSize);
-  if (!E) {
-    DP("Unable to get ELF handle: %s!\n", elf_errmsg(-1));
-    return NULL;
-  }
-
-  if (elf_kind(E) != ELF_K_ELF) {
-    DP("Invalid Elf kind!\n");
-    elf_end(E);
-    return NULL;
-  }
-
-  // Find the entries section offset
-  Elf_Scn *Section = 0;
-  Elf64_Off EntriesOffset = 0;
-
-  size_t Shstrndx;
-
-  if (elf_getshdrstrndx(E, &Shstrndx)) {
-    DP("Unable to get ELF strings index!\n");
-    elf_end(E);
-    return NULL;
-  }
-
-  while ((Section = elf_nextscn(E, Section))) {
-    GElf_Shdr Hdr;
-    gelf_getshdr(Section, &Hdr);
-
-    if (!strcmp(elf_strptr(E, Shstrndx, Hdr.sh_name), OFFLOADSECTIONNAME)) {
-      EntriesOffset = Hdr.sh_addr;
-      break;
-    }
-  }
-
-  if (!EntriesOffset) {
-    DP("Entries Section Offset Not Found\n");
-    elf_end(E);
-    return NULL;
-  }
-
-  DP("Offset of entries section is (" DPxMOD ").\n", DPxPTR(EntriesOffset));
-
   // load dynamic library and get the entry points. We use the dl library
   // to do the loading of the library, but we could do it directly to avoid the
   // dump to the temporary file.
   //
   // 1) Create tmp file with the library contents.
   // 2) Use dlopen to load the file and dlsym to retrieve the symbols.
   char TmpName[] = "/tmp/tmpfile_XXXXXX";
   int TmpFd = mkstemp(TmpName);
 
-  if (TmpFd == -1) {
-    elf_end(E);
-    return NULL;
-  }
+  if (TmpFd == -1)
+    return nullptr;
 
   FILE *Ftmp = fdopen(TmpFd, "wb");
 
-  if (!Ftmp) {
-    elf_end(E);
-    return NULL;
-  }
+  if (!Ftmp)
+    return nullptr;
 
   fwrite(Image->ImageStart, ImageSize, 1, Ftmp);
   fclose(Ftmp);
 
   DynLibTy Lib = {TmpName, dlopen(TmpName, RTLD_LAZY)};
 
   if (!Lib.Handle) {
     DP("Target library loading error: %s\n", dlerror());
-    elf_end(E);
     return NULL;
   }
 
   DeviceInfo.DynLibs.push_back(Lib);
 
-  struct link_map *LibInfo = (struct link_map *)Lib.Handle;
+  __tgt_offload_entry *HostBegin = Image->EntriesBegin;
+  __tgt_offload_entry *HostEnd = Image->EntriesEnd;
 
-  // The place where the entries info is loaded is the library base address
-  // plus the offset determined from the ELF file.
-  Elf64_Addr EntriesAddr = LibInfo->l_addr + EntriesOffset;
+  // 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;
 
-  DP("Pointer to first entry to be loaded is (" DPxMOD ").\n",
-     DPxPTR(EntriesAddr));
+    __tgt_offload_entry Entry = *E;
 
-  // Table of pointers to all the entries in the target.
-  __tgt_offload_entry *EntriesTable = (__tgt_offload_entry *)EntriesAddr;
+    void *DevAddr = dlsym(Lib.Handle, E->name);
+    Entry.addr = DevAddr;
 
-  __tgt_offload_entry *EntriesBegin = &EntriesTable[0];
-  __tgt_offload_entry *EntriesEnd = EntriesBegin + NumEntries;
+    DP("Entry point " DPxMOD " maps to global %s (" DPxMOD ")\n",
+       DPxPTR(E - HostBegin), E->name, DPxPTR(DevAddr));
 
-  if (!EntriesBegin) {
-    DP("Can't obtain entries begin\n");
-    elf_end(E);
-    return NULL;
+    Entries.emplace_back(Entry);
   }
 
-  DP("Entries table range is (" DPxMOD ")->(" DPxMOD ")\n",
-     DPxPTR(EntriesBegin), DPxPTR(EntriesEnd));
-  DeviceInfo.createOffloadTable(DeviceId, EntriesBegin, EntriesEnd);
-
-  elf_end(E);
+  DeviceInfo.createOffloadTable(DeviceId, std::move(Entries));
 
   return DeviceInfo.getOffloadEntriesTable(DeviceId);
 }
 
 void __tgt_rtl_print_device_info(int32_t DeviceId) {
   printf("    This is a generic-elf-64bit device\n");
 }