Skip to content

Commit

Permalink
Revert "[libomptarget] Support BE ELF files in plugins-nextgen (#85246)"
Browse files Browse the repository at this point in the history 
This reverts commit 611c62b.
  • Loading branch information
@uweigand
uweigand committed Mar 14, 2024
1 parent 4e232ca commit 4c8714e
Show file tree
Hide file tree
Showing 5 changed files with 50 additions and 90 deletions.
2 changes: 1 addition & 1 deletion openmp/libomptarget/plugins-nextgen/common/include/GlobalHandler.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,7 +104,7 @@ class GenericGlobalHandlerTy {
virtual ~GenericGlobalHandlerTy() {}

/// Helper function for getting an ELF from a device image.
Expected<std::unique_ptr<ObjectFile>> getELFObjectFile(DeviceImageTy &Image);
Expected<ELF64LEObjectFile> getELFObjectFile(DeviceImageTy &Image);

/// Returns whether the symbol named \p SymName is present in the given \p
/// Image.
Expand Down
10 changes: 6 additions & 4 deletions openmp/libomptarget/plugins-nextgen/common/include/Utils/ELF.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,15 +28,17 @@ bool isELF(llvm::StringRef Buffer);
llvm::Expected<bool> checkMachine(llvm::StringRef Object, uint16_t EMachine);

/// Returns a pointer to the given \p Symbol inside of an ELF object.
llvm::Expected<const void *>
getSymbolAddress(const llvm::object::ELFSymbolRef &Symbol);
llvm::Expected<const void *> getSymbolAddress(
const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
const llvm::object::ELF64LE::Sym &Symbol);

/// 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<std::optional<llvm::object::ELFSymbolRef>>
getSymbol(const llvm::object::ObjectFile &ELFObj, llvm::StringRef Name);
llvm::Expected<const typename llvm::object::ELF64LE::Sym *>
getSymbol(const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
llvm::StringRef Name);

} // namespace elf
} // namespace utils
Expand Down
16 changes: 9 additions & 7 deletions openmp/libomptarget/plugins-nextgen/common/src/GlobalHandler.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -25,12 +25,14 @@ using namespace omp;
using namespace target;
using namespace plugin;

Expected<std::unique_ptr<ObjectFile>>
Expected<ELF64LEObjectFile>
GenericGlobalHandlerTy::getELFObjectFile(DeviceImageTy &Image) {
assert(utils::elf::isELF(Image.getMemoryBuffer().getBuffer()) &&
"Input is not an ELF file");

return ELFObjectFileBase::createELFObjectFile(Image.getMemoryBuffer());
Expected<ELF64LEObjectFile> ElfOrErr =
ELF64LEObjectFile::create(Image.getMemoryBuffer());
return ElfOrErr;
}

Error GenericGlobalHandlerTy::moveGlobalBetweenDeviceAndHost(
Expand Down Expand Up @@ -89,13 +91,13 @@ bool GenericGlobalHandlerTy::isSymbolInImage(GenericDeviceTy &Device,
}

// Search the ELF symbol using the symbol name.
auto SymOrErr = utils::elf::getSymbol(**ELFObjOrErr, SymName);
auto SymOrErr = utils::elf::getSymbol(*ELFObjOrErr, SymName);
if (!SymOrErr) {
consumeError(SymOrErr.takeError());
return false;
}

return SymOrErr->has_value();
return *SymOrErr;
}

Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
Expand All @@ -108,7 +110,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
return ELFObj.takeError();

// Search the ELF symbol using the symbol name.
auto SymOrErr = utils::elf::getSymbol(**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(),
Expand All @@ -118,7 +120,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
return Plugin::error("Failed to find global symbol '%s' in the ELF image",
ImageGlobal.getName().data());

auto AddrOrErr = utils::elf::getSymbolAddress(**SymOrErr);
auto AddrOrErr = utils::elf::getSymbolAddress(*ELFObj, **SymOrErr);
// Get the section to which the symbol belongs.
if (!AddrOrErr)
return Plugin::error("Failed to get ELF symbol from global '%s': %s",
Expand All @@ -127,7 +129,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(

// Setup the global symbol's address and size.
ImageGlobal.setPtr(const_cast<void *>(*AddrOrErr));
ImageGlobal.setSize((*SymOrErr)->getSize());
ImageGlobal.setSize((*SymOrErr)->st_size);

return Plugin::success();
}
Expand Down
110 changes: 33 additions & 77 deletions openmp/libomptarget/plugins-nextgen/common/src/Utils/ELF.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,10 +36,18 @@ bool utils::elf::isELF(StringRef Buffer) {
}
}

template <class ELFT>
static Expected<bool>
checkMachineImpl(const object::ELFObjectFile<ELFT> &ELFObj, uint16_t EMachine) {
const auto Header = ELFObj.getELFFile().getHeader();
Expected<bool> utils::elf::checkMachine(StringRef Object, uint16_t EMachine) {
assert(isELF(Object) && "Input is not an ELF!");

Expected<ELF64LEObjectFile> ElfOrErr =
ELF64LEObjectFile::create(MemoryBufferRef(Object, /*Identifier=*/""),
/*InitContent=*/false);
if (!ElfOrErr)
return ElfOrErr.takeError();

const auto Header = ElfOrErr->getELFFile().getHeader();
if (Header.e_ident[EI_CLASS] != ELFCLASS64)
return createError("Only 64-bit ELF files are supported");
if (Header.e_type != ET_EXEC && Header.e_type != ET_DYN)
return createError("Only executable ELF files are supported");

Expand All @@ -63,25 +71,6 @@ checkMachineImpl(const object::ELFObjectFile<ELFT> &ELFObj, uint16_t EMachine) {
return Header.e_machine == EMachine;
}

Expected<bool> utils::elf::checkMachine(StringRef Object, uint16_t EMachine) {
assert(isELF(Object) && "Input is not an ELF!");

Expected<std::unique_ptr<ObjectFile>> ElfOrErr =
ObjectFile::createELFObjectFile(
MemoryBufferRef(Object, /*Identifier=*/""),
/*InitContent=*/false);
if (!ElfOrErr)
return ElfOrErr.takeError();

if (const ELF64LEObjectFile *ELFObj =
dyn_cast<ELF64LEObjectFile>(&**ElfOrErr))
return checkMachineImpl(*ELFObj, EMachine);
if (const ELF64BEObjectFile *ELFObj =
dyn_cast<ELF64BEObjectFile>(&**ElfOrErr))
return checkMachineImpl(*ELFObj, EMachine);
return createError("Only 64-bit ELF files are supported");
}

template <class ELFT>
static Expected<const typename ELFT::Sym *>
getSymbolFromGnuHashTable(StringRef Name, const typename ELFT::GnuHash &HashTab,
Expand Down Expand Up @@ -149,10 +138,9 @@ getSymbolFromSysVHashTable(StringRef Name, const typename ELFT::Hash &HashTab,
}

template <class ELFT>
static Expected<std::optional<ELFSymbolRef>>
getHashTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
const typename ELFT::Shdr &Sec, StringRef Name) {
const ELFFile<ELFT> &Elf = ELFObj.getELFFile();
static Expected<const typename ELFT::Sym *>
getHashTableSymbol(const ELFFile<ELFT> &Elf, const typename ELFT::Shdr &Sec,
StringRef Name) {
if (Sec.sh_type != ELF::SHT_HASH && Sec.sh_type != ELF::SHT_GNU_HASH)
return createError(
"invalid sh_type for hash table, expected SHT_HASH or SHT_GNU_HASH");
Expand Down Expand Up @@ -191,10 +179,7 @@ getHashTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
sizeof(typename ELFT::Word) * HashTab->nbuckets +
sizeof(typename ELFT::Word) * (SymTab.size() - HashTab->symndx))
return createError("section has invalid sh_size: " + Twine(Sec.sh_size));
auto Sym = getSymbolFromGnuHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
if (!Sym)
return Sym.takeError();
return ELFObj.toSymbolRef(*SymTabOrErr, *Sym - &SymTab[0]);
return getSymbolFromGnuHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
}

// If this is a Sys-V hash table we verify its size and search the symbol
Expand All @@ -212,20 +197,16 @@ getHashTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
sizeof(typename ELFT::Word) * HashTab->nchain)
return createError("section has invalid sh_size: " + Twine(Sec.sh_size));

auto Sym = getSymbolFromSysVHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
if (!Sym)
return Sym.takeError();
return ELFObj.toSymbolRef(*SymTabOrErr, *Sym - &SymTab[0]);
return getSymbolFromSysVHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
}

return std::nullopt;
return nullptr;
}

template <class ELFT>
static Expected<std::optional<ELFSymbolRef>>
getSymTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
const typename ELFT::Shdr &Sec, StringRef Name) {
const ELFFile<ELFT> &Elf = ELFObj.getELFFile();
static Expected<const typename ELFT::Sym *>
getSymTableSymbol(const ELFFile<ELFT> &Elf, const typename ELFT::Shdr &Sec,
StringRef Name) {
if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
return createError(
"invalid sh_type for hash table, expected SHT_SYMTAB or SHT_DYNSYM");
Expand All @@ -245,14 +226,13 @@ getSymTableSymbol(const ELFObjectFile<ELFT> &ELFObj,

for (const typename ELFT::Sym &Sym : SymTab)
if (StrTab.drop_front(Sym.st_name).data() == Name)
return ELFObj.toSymbolRef(&Sec, &Sym - &SymTab[0]);
return &Sym;

return std::nullopt;
return nullptr;
}

template <class ELFT>
static Expected<std::optional<ELFSymbolRef>>
getSymbolImpl(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
Expected<const typename ELF64LE::Sym *>
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)
Expand All @@ -261,7 +241,8 @@ getSymbolImpl(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
auto HashTabOrErr = ELFObj.getELFFile().getSection(Sec.getIndex());
if (!HashTabOrErr)
return HashTabOrErr.takeError();
return getHashTableSymbol<ELFT>(ELFObj, **HashTabOrErr, Name);
return getHashTableSymbol<ELF64LE>(ELFObj.getELFFile(), **HashTabOrErr,
Name);
}

// If this is an executable file check the entire standard symbol table.
Expand All @@ -272,31 +253,16 @@ getSymbolImpl(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
auto SymTabOrErr = ELFObj.getELFFile().getSection(Sec.getIndex());
if (!SymTabOrErr)
return SymTabOrErr.takeError();
return getSymTableSymbol<ELFT>(ELFObj, **SymTabOrErr, Name);
return getSymTableSymbol<ELF64LE>(ELFObj.getELFFile(), **SymTabOrErr, Name);
}

return std::nullopt;
}

Expected<std::optional<ELFSymbolRef>>
utils::elf::getSymbol(const ObjectFile &Obj, StringRef Name) {
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj))
return getSymbolImpl(*ELFObj, Name);
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(&Obj))
return getSymbolImpl(*ELFObj, Name);
return createError("Only 64-bit ELF files are supported");
return nullptr;
}

template <class ELFT>
static Expected<const void *>
getSymbolAddressImpl(const ELFObjectFile<ELFT> &ELFObj,
const ELFSymbolRef &SymRef) {
const ELFFile<ELFT> &ELFFile = ELFObj.getELFFile();

auto SymOrErr = ELFObj.getSymbol(SymRef.getRawDataRefImpl());
if (!SymOrErr)
return SymOrErr.takeError();
const auto &Symbol = **SymOrErr;
Expected<const void *> utils::elf::getSymbolAddress(
const object::ELFObjectFile<object::ELF64LE> &ELFObj,
const object::ELF64LE::Sym &Symbol) {
const ELFFile<ELF64LE> &ELFFile = ELFObj.getELFFile();

auto SecOrErr = ELFFile.getSection(Symbol.st_shndx);
if (!SecOrErr)
Expand All @@ -317,13 +283,3 @@ getSymbolAddressImpl(const ELFObjectFile<ELFT> &ELFObj,

return ELFFile.base() + Offset;
}

Expected<const void *>
utils::elf::getSymbolAddress(const ELFSymbolRef &SymRef) {
const ObjectFile *Obj = SymRef.getObject();
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
return getSymbolAddressImpl(*ELFObj, SymRef);
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
return getSymbolAddressImpl(*ELFObj, SymRef);
return createError("Only 64-bit ELF files are supported");
}
2 changes: 1 addition & 1 deletion openmp/libomptarget/plugins-nextgen/cuda/src/rtl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1166,7 +1166,7 @@ struct CUDADeviceTy : public GenericDeviceTy {

// Search for all symbols that contain a constructor or destructor.
SmallVector<std::pair<StringRef, uint16_t>> Funcs;
for (ELFSymbolRef Sym : (*ELFObjOrErr)->symbols()) {
for (ELFSymbolRef Sym : ELFObjOrErr->symbols()) {
auto NameOrErr = Sym.getName();
if (!NameOrErr)
return NameOrErr.takeError();
Expand Down

0 comments on commit 4c8714e

Please sign in to comment.