[OpenMP][NFC] Merge elf_common into PluginInterface (#73677)

The overhead of a library and 4 files seems high without benefit. This
simply tries to consolidate our structure.

Author: jdoerfert

openmp/libomptarget/plugins-nextgen/CMakeLists.txt

@@ -47,7 +47,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "${tmachine}$")
 
         LINK_LIBS
         PRIVATE
-        elf_common
         MemoryManager
         PluginInterface
         ${LIBOMPTARGET_DEP_LIBFFI_LIBRARIES}

openmp/libomptarget/plugins-nextgen/amdgpu/CMakeLists.txt

@@ -80,7 +80,6 @@ add_llvm_library(omptarget.rtl.amdgpu SHARED
 
   LINK_LIBS
   PRIVATE
-  elf_common
   MemoryManager
   PluginInterface
   ${LIBOMPTARGET_DEP_LIBRARIES}

openmp/libomptarget/plugins-nextgen/common/CMakeLists.txt

@@ -13,4 +13,3 @@
 add_subdirectory(OMPT)
 add_subdirectory(PluginInterface)
 add_subdirectory(MemoryManager)
-add_subdirectory(elf_common)

openmp/libomptarget/plugins-nextgen/common/OMPT/CMakeLists.txt

@@ -52,7 +52,6 @@ endif()
 target_link_libraries(OMPT
   PUBLIC
     ${llvm_libs}
-    elf_common
     MemoryManager
 )
 

openmp/libomptarget/plugins-nextgen/common/PluginInterface/CMakeLists.txt

@@ -13,7 +13,12 @@
 # NOTE: Don't try to build `PluginInterface` using `add_llvm_library` because we
 # don't want to export `PluginInterface` while `add_llvm_library` requires that.
 add_library(PluginInterface OBJECT
-  PluginInterface.cpp GlobalHandler.cpp JIT.cpp RPC.cpp)
+  PluginInterface.cpp
+  GlobalHandler.cpp
+  JIT.cpp
+  RPC.cpp
+  Utils/ELF.cpp
+)
 
 # Only enable JIT for those targets that LLVM can support.
 string(TOUPPER "${LLVM_TARGETS_TO_BUILD}" TargetsSupported)
@@ -58,7 +63,6 @@ endif()
 target_link_libraries(PluginInterface
   PUBLIC
     ${llvm_libs}
-    elf_common
     MemoryManager
 )
 

openmp/libomptarget/plugins-nextgen/common/PluginInterface/GlobalHandler.cpp

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "GlobalHandler.h"
-#include "ELFSymbols.h"
 #include "PluginInterface.h"
 #include "Utilities.h"
+#include "Utils/ELF.h"
 
 #include <cstring>
 
@@ -115,7 +115,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
                          Image.getStart());
 
   // Search the ELF symbol using the symbol name.
-  auto SymOrErr = getELFSymbol(*ELFObj, ImageGlobal.getName());
+  auto SymOrErr = utils::elf::getSymbol(*ELFObj, ImageGlobal.getName());
   if (!SymOrErr)
     return Plugin::error("Failed ELF lookup of global '%s': %s",
                          ImageGlobal.getName().data(),

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.cpp

@@ -13,7 +13,7 @@
 #include "Environment.h"
 #include "GlobalHandler.h"
 #include "JIT.h"
-#include "elf_common.h"
+#include "Utils/ELF.h"
 #include "omptarget.h"
 #include "omptargetplugin.h"
 
@@ -1636,7 +1636,7 @@ int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *TgtImage) {
   if (!Plugin::isActive())
     return false;
 
-  if (elf_check_machine(TgtImage, Plugin::get().getMagicElfBits()))
+  if (utils::elf::checkMachine(TgtImage, Plugin::get().getMagicElfBits()))
     return true;
 
   return Plugin::get().getJIT().checkBitcodeImage(*TgtImage);

openmp/libomptarget/plugins-nextgen/common/elf_common/ELFSymbols.cpp renamed to openmp/libomptarget/plugins-nextgen/common/PluginInterface/Utils/ELF.cpp

@@ -1,16 +1,76 @@
-//===-- ELFSymbols.cpp - ELF Symbol look-up functionality -------*- C++ -*-===//
+//===-- Utils/ELF.cpp - Common ELF functionality --------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
+//
+// Common ELF functionality for target plugins.
+//
+//===----------------------------------------------------------------------===//
 
-#include "ELFSymbols.h"
+#include "ELF.h"
+#include "Debug.h"
+
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/MemoryBuffer.h"
 
 using namespace llvm;
-using namespace llvm::object;
 using namespace llvm::ELF;
+using namespace llvm::object;
+
+/// If the given range of bytes [\p BytesBegin, \p BytesEnd) represents
+/// a valid ELF, then invoke \p Callback on the ELFObjectFileBase
+/// created from this range, otherwise, return 0.
+/// If \p Callback is invoked, then return whatever value \p Callback returns.
+template <typename F>
+static int32_t withBytesAsElf(char *BytesBegin, char *BytesEnd, F Callback) {
+  size_t Size = BytesEnd - BytesBegin;
+  StringRef StrBuf(BytesBegin, Size);
+
+  auto Magic = identify_magic(StrBuf);
+  if (Magic != file_magic::elf && Magic != file_magic::elf_relocatable &&
+      Magic != file_magic::elf_executable &&
+      Magic != file_magic::elf_shared_object && Magic != file_magic::elf_core) {
+    DP("Not an ELF image!\n");
+    return 0;
+  }
+
+  std::unique_ptr<MemoryBuffer> MemBuf =
+      MemoryBuffer::getMemBuffer(StrBuf, "", false);
+  Expected<std::unique_ptr<ObjectFile>> BinOrErr =
+      ObjectFile::createELFObjectFile(MemBuf->getMemBufferRef(),
+                                      /*InitContent=*/false);
+  if (!BinOrErr) {
+    DP("Unable to get ELF handle: %s!\n",
+       toString(BinOrErr.takeError()).c_str());
+    return 0;
+  }
+
+  auto *Object = dyn_cast<const ELFObjectFileBase>(BinOrErr->get());
+
+  if (!Object) {
+    DP("Unknown ELF format!\n");
+    return 0;
+  }
+
+  return Callback(Object);
+}
+
+// Check whether an image is valid for execution on target_id
+int32_t utils::elf::checkMachine(__tgt_device_image *Image, uint16_t TargetId) {
+  auto CheckMachine = [TargetId](const ELFObjectFileBase *Object) {
+    return TargetId == Object->getEMachine();
+  };
+  return withBytesAsElf(reinterpret_cast<char *>(Image->ImageStart),
+                        reinterpret_cast<char *>(Image->ImageEnd),
+                        CheckMachine);
+}
 
 template <class ELFT>
 static Expected<const typename ELFT::Sym *>
@@ -173,7 +233,7 @@ getSymTableSymbol(const ELFFile<ELFT> &Elf, const typename ELFT::Shdr &Sec,
 }
 
 Expected<const typename ELF64LE::Sym *>
-getELFSymbol(const ELFObjectFile<ELF64LE> &ELFObj, StringRef Name) {
+utils::elf::getSymbol(const ELFObjectFile<ELF64LE> &ELFObj, StringRef Name) {
   // First try to look up the symbol via the hash table.
   for (ELFSectionRef Sec : ELFObj.sections()) {
     if (Sec.getType() != SHT_HASH && Sec.getType() != SHT_GNU_HASH)

openmp/libomptarget/plugins-nextgen/common/elf_common/ELFSymbols.h renamed to openmp/libomptarget/plugins-nextgen/common/PluginInterface/Utils/ELF.h

@@ -1,27 +1,39 @@
-//===-- ELFSymbols.h - ELF Symbol look-up functionality ---------*- C++ -*-===//
+//===-- Utils/ELF.h - Common ELF functionality ------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
-// ELF routines for obtaining a symbol from an Elf file without loading it.
+// Common ELF functionality for target plugins.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_ELF_COMMON_ELF_SYMBOLS_H
-#define LLVM_OPENMP_LIBOMPTARGET_PLUGINS_COMMON_ELF_COMMON_ELF_SYMBOLS_H
+#ifndef LLVM_OPENMP_LIBOMPTARGET_PLUGINS_ELF_UTILS_H
+#define LLVM_OPENMP_LIBOMPTARGET_PLUGINS_ELF_UTILS_H
+
+#include "omptargetplugin.h"
 
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/ELFObjectFile.h"
 
+namespace utils {
+namespace elf {
+
+/// Return non-zero, if the given \p image is an ELF object, which
+/// e_machine matches \p target_id; return zero otherwise.
+EXTERN int32_t checkMachine(__tgt_device_image *Image, uint16_t TargetId);
+
 /// Returns the symbol associated with the \p Name in the \p ELFObj. It will
 /// first search for the hash sections to identify symbols from the hash table.
 /// If that fails it will fall back to a linear search in the case of an
 /// executable file without a hash table.
 llvm::Expected<const typename llvm::object::ELF64LE::Sym *>
-getELFSymbol(const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
-             llvm::StringRef Name);
+getSymbol(const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
+          llvm::StringRef Name);
+
+} // namespace elf
+} // namespace utils
 
-#endif
+#endif // LLVM_OPENMP_LIBOMPTARGET_PLUGINS_ELF_UTILS_H

openmp/libomptarget/plugins-nextgen/common/elf_common/CMakeLists.txt

@@ -34,7 +34,6 @@ add_llvm_library(omptarget.rtl.cuda SHARED
   Object
 
   LINK_LIBS PRIVATE
-  elf_common
   MemoryManager
   PluginInterface
   ${OPENMP_PTHREAD_LIB}