Skip to content

Commit fb7cc73

Browse files
uweiganduweigand
committed
Revert "[libomptarget] Support BE ELF files in plugins-nextgen (#83976)"
This reverts commit 15b7b31.
1 parent 70677c8 commit fb7cc73

File tree

4 files changed

+71
-85
lines changed

4 files changed

+71
-85
lines changed

‎openmp/libomptarget/plugins-nextgen/common/include/GlobalHandler.h

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,9 @@ class GenericGlobalHandlerTy {
103103
public:
104104
virtual ~GenericGlobalHandlerTy() {}
105105

106+
/// Helper function for getting an ELF from a device image.
107+
Expected<ELF64LEObjectFile> getELFObjectFile(DeviceImageTy &Image);
108+
106109
/// Returns whether the symbol named \p SymName is present in the given \p
107110
/// Image.
108111
bool isSymbolInImage(GenericDeviceTy &Device, DeviceImageTy &Image,

‎openmp/libomptarget/plugins-nextgen/common/include/Utils/ELF.h

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -27,14 +27,18 @@ bool isELF(llvm::StringRef Buffer);
2727
/// Checks if the given \p Object is a valid ELF matching the e_machine value.
2828
llvm::Expected<bool> checkMachine(llvm::StringRef Object, uint16_t EMachine);
2929

30-
/// Returns the symbol associated with the \p Name in the \p Obj. It will
30+
/// Returns a pointer to the given \p Symbol inside of an ELF object.
31+
llvm::Expected<const void *> getSymbolAddress(
32+
const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
33+
const llvm::object::ELF64LE::Sym &Symbol);
34+
35+
/// Returns the symbol associated with the \p Name in the \p ELFObj. It will
3136
/// first search for the hash sections to identify symbols from the hash table.
3237
/// If that fails it will fall back to a linear search in the case of an
33-
/// executable file without a hash table. If the symbol is found, it returns
34-
/// a StringRef covering the symbol's data in the Obj buffer, based on its
35-
/// address and size; otherwise, it returns std::nullopt.
36-
llvm::Expected<std::optional<llvm::StringRef>>
37-
findSymbolInImage(const llvm::StringRef Obj, llvm::StringRef Name);
38+
/// executable file without a hash table.
39+
llvm::Expected<const typename llvm::object::ELF64LE::Sym *>
40+
getSymbol(const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
41+
llvm::StringRef Name);
3842

3943
} // namespace elf
4044
} // namespace utils

‎openmp/libomptarget/plugins-nextgen/common/src/GlobalHandler.cpp

Lines changed: 37 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,16 @@ using namespace omp;
2525
using namespace target;
2626
using namespace plugin;
2727

28+
Expected<ELF64LEObjectFile>
29+
GenericGlobalHandlerTy::getELFObjectFile(DeviceImageTy &Image) {
30+
assert(utils::elf::isELF(Image.getMemoryBuffer().getBuffer()) &&
31+
"Input is not an ELF file");
32+
33+
Expected<ELF64LEObjectFile> ElfOrErr =
34+
ELF64LEObjectFile::create(Image.getMemoryBuffer());
35+
return ElfOrErr;
36+
}
37+
2838
Error GenericGlobalHandlerTy::moveGlobalBetweenDeviceAndHost(
2939
GenericDeviceTy &Device, DeviceImageTy &Image, const GlobalTy &HostGlobal,
3040
bool Device2Host) {
@@ -71,37 +81,55 @@ Error GenericGlobalHandlerTy::moveGlobalBetweenDeviceAndHost(
7181
bool GenericGlobalHandlerTy::isSymbolInImage(GenericDeviceTy &Device,
7282
DeviceImageTy &Image,
7383
StringRef SymName) {
84+
// Get the ELF object file for the image. Notice the ELF object may already
85+
// be created in previous calls, so we can reuse it. If this is unsuccessful
86+
// just return false as we couldn't find it.
87+
auto ELFObjOrErr = getELFObjectFile(Image);
88+
if (!ELFObjOrErr) {
89+
consumeError(ELFObjOrErr.takeError());
90+
return false;
91+
}
7492

7593
// Search the ELF symbol using the symbol name.
76-
auto SymOrErr = utils::elf::findSymbolInImage(
77-
Image.getMemoryBuffer().getBuffer(), SymName);
94+
auto SymOrErr = utils::elf::getSymbol(*ELFObjOrErr, SymName);
7895
if (!SymOrErr) {
7996
consumeError(SymOrErr.takeError());
8097
return false;
8198
}
8299

83-
return SymOrErr->has_value();
100+
return *SymOrErr;
84101
}
85102

86103
Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
87104
GenericDeviceTy &Device, DeviceImageTy &Image, GlobalTy &ImageGlobal) {
88105

106+
// Get the ELF object file for the image. Notice the ELF object may already
107+
// be created in previous calls, so we can reuse it.
108+
auto ELFObj = getELFObjectFile(Image);
109+
if (!ELFObj)
110+
return ELFObj.takeError();
111+
89112
// Search the ELF symbol using the symbol name.
90-
auto SymOrErr = utils::elf::findSymbolInImage(
91-
Image.getMemoryBuffer().getBuffer(), ImageGlobal.getName());
113+
auto SymOrErr = utils::elf::getSymbol(*ELFObj, ImageGlobal.getName());
92114
if (!SymOrErr)
93115
return Plugin::error("Failed ELF lookup of global '%s': %s",
94116
ImageGlobal.getName().data(),
95117
toString(SymOrErr.takeError()).data());
96118

97-
if (!SymOrErr->has_value())
119+
if (!*SymOrErr)
98120
return Plugin::error("Failed to find global symbol '%s' in the ELF image",
99121
ImageGlobal.getName().data());
100122

123+
auto AddrOrErr = utils::elf::getSymbolAddress(*ELFObj, **SymOrErr);
124+
// Get the section to which the symbol belongs.
125+
if (!AddrOrErr)
126+
return Plugin::error("Failed to get ELF symbol from global '%s': %s",
127+
ImageGlobal.getName().data(),
128+
toString(AddrOrErr.takeError()).data());
129+
101130
// Setup the global symbol's address and size.
102-
auto Symbol = **SymOrErr;
103-
ImageGlobal.setPtr(static_cast<void *>(const_cast<char *>(Symbol.data())));
104-
ImageGlobal.setSize(Symbol.size());
131+
ImageGlobal.setPtr(const_cast<void *>(*AddrOrErr));
132+
ImageGlobal.setSize((*SymOrErr)->st_size);
105133

106134
return Plugin::success();
107135
}

‎openmp/libomptarget/plugins-nextgen/common/src/Utils/ELF.cpp

Lines changed: 21 additions & 70 deletions
Original file line numberDiff line numberDiff line change
@@ -36,10 +36,18 @@ bool utils::elf::isELF(StringRef Buffer) {
3636
}
3737
}
3838

39-
template <class ELFT>
40-
static Expected<bool>
41-
checkMachineImpl(const object::ELFObjectFile<ELFT> &ELFObj, uint16_t EMachine) {
42-
const auto Header = ELFObj.getELFFile().getHeader();
39+
Expected<bool> utils::elf::checkMachine(StringRef Object, uint16_t EMachine) {
40+
assert(isELF(Object) && "Input is not an ELF!");
41+
42+
Expected<ELF64LEObjectFile> ElfOrErr =
43+
ELF64LEObjectFile::create(MemoryBufferRef(Object, /*Identifier=*/""),
44+
/*InitContent=*/false);
45+
if (!ElfOrErr)
46+
return ElfOrErr.takeError();
47+
48+
const auto Header = ElfOrErr->getELFFile().getHeader();
49+
if (Header.e_ident[EI_CLASS] != ELFCLASS64)
50+
return createError("Only 64-bit ELF files are supported");
4351
if (Header.e_type != ET_EXEC && Header.e_type != ET_DYN)
4452
return createError("Only executable ELF files are supported");
4553

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

66-
Expected<bool> utils::elf::checkMachine(StringRef Object, uint16_t EMachine) {
67-
assert(isELF(Object) && "Input is not an ELF!");
68-
69-
Expected<std::unique_ptr<ObjectFile>> ElfOrErr =
70-
ObjectFile::createELFObjectFile(
71-
MemoryBufferRef(Object, /*Identifier=*/""),
72-
/*InitContent=*/false);
73-
if (!ElfOrErr)
74-
return ElfOrErr.takeError();
75-
76-
if (const ELF64LEObjectFile *ELFObj =
77-
dyn_cast<ELF64LEObjectFile>(&**ElfOrErr))
78-
return checkMachineImpl(*ELFObj, EMachine);
79-
if (const ELF64BEObjectFile *ELFObj =
80-
dyn_cast<ELF64BEObjectFile>(&**ElfOrErr))
81-
return checkMachineImpl(*ELFObj, EMachine);
82-
return createError("Only 64-bit ELF files are supported");
83-
}
84-
8574
template <class ELFT>
8675
static Expected<const typename ELFT::Sym *>
8776
getSymbolFromGnuHashTable(StringRef Name, const typename ELFT::GnuHash &HashTab,
@@ -242,9 +231,8 @@ getSymTableSymbol(const ELFFile<ELFT> &Elf, const typename ELFT::Shdr &Sec,
242231
return nullptr;
243232
}
244233

245-
template <class ELFT>
246-
static Expected<const typename ELFT::Sym *>
247-
getSymbol(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
234+
Expected<const typename ELF64LE::Sym *>
235+
utils::elf::getSymbol(const ELFObjectFile<ELF64LE> &ELFObj, StringRef Name) {
248236
// First try to look up the symbol via the hash table.
249237
for (ELFSectionRef Sec : ELFObj.sections()) {
250238
if (Sec.getType() != SHT_HASH && Sec.getType() != SHT_GNU_HASH)
@@ -253,7 +241,8 @@ getSymbol(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
253241
auto HashTabOrErr = ELFObj.getELFFile().getSection(Sec.getIndex());
254242
if (!HashTabOrErr)
255243
return HashTabOrErr.takeError();
256-
return getHashTableSymbol<ELFT>(ELFObj.getELFFile(), **HashTabOrErr, Name);
244+
return getHashTableSymbol<ELF64LE>(ELFObj.getELFFile(), **HashTabOrErr,
245+
Name);
257246
}
258247

259248
// If this is an executable file check the entire standard symbol table.
@@ -264,17 +253,16 @@ getSymbol(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
264253
auto SymTabOrErr = ELFObj.getELFFile().getSection(Sec.getIndex());
265254
if (!SymTabOrErr)
266255
return SymTabOrErr.takeError();
267-
return getSymTableSymbol<ELFT>(ELFObj.getELFFile(), **SymTabOrErr, Name);
256+
return getSymTableSymbol<ELF64LE>(ELFObj.getELFFile(), **SymTabOrErr, Name);
268257
}
269258

270259
return nullptr;
271260
}
272261

273-
template <class ELFT>
274-
static Expected<const void *>
275-
getSymbolAddress(const object::ELFObjectFile<ELFT> &ELFObj,
276-
const typename ELFT::Sym &Symbol) {
277-
const ELFFile<ELFT> &ELFFile = ELFObj.getELFFile();
262+
Expected<const void *> utils::elf::getSymbolAddress(
263+
const object::ELFObjectFile<object::ELF64LE> &ELFObj,
264+
const object::ELF64LE::Sym &Symbol) {
265+
const ELFFile<ELF64LE> &ELFFile = ELFObj.getELFFile();
278266

279267
auto SecOrErr = ELFFile.getSection(Symbol.st_shndx);
280268
if (!SecOrErr)
@@ -295,40 +283,3 @@ getSymbolAddress(const object::ELFObjectFile<ELFT> &ELFObj,
295283

296284
return ELFFile.base() + Offset;
297285
}
298-
299-
template <class ELFT>
300-
static Expected<std::optional<StringRef>>
301-
findSymbolInImageImpl(const object::ELFObjectFile<ELFT> &ELFObj,
302-
StringRef Name) {
303-
auto SymOrErr = getSymbol(ELFObj, Name);
304-
if (!SymOrErr)
305-
return SymOrErr.takeError();
306-
if (!*SymOrErr)
307-
return std::nullopt;
308-
309-
// If the symbol was found, return a StringRef covering the associated data,
310-
// based on the symbol's address and size.
311-
auto AddrOrErr = getSymbolAddress(ELFObj, **SymOrErr);
312-
if (!AddrOrErr)
313-
return AddrOrErr.takeError();
314-
return StringRef(static_cast<const char *>(*AddrOrErr), (*SymOrErr)->st_size);
315-
}
316-
317-
Expected<std::optional<StringRef>>
318-
utils::elf::findSymbolInImage(StringRef Obj, StringRef Name) {
319-
assert(isELF(Obj) && "Input is not an ELF!");
320-
321-
Expected<std::unique_ptr<ObjectFile>> ElfOrErr =
322-
ObjectFile::createELFObjectFile(MemoryBufferRef(Obj, /*Identifier=*/""),
323-
/*InitContent=*/false);
324-
if (!ElfOrErr)
325-
return ElfOrErr.takeError();
326-
327-
if (const ELF64LEObjectFile *ELFObj =
328-
dyn_cast<ELF64LEObjectFile>(&**ElfOrErr))
329-
return findSymbolInImageImpl(*ELFObj, Name);
330-
if (const ELF64BEObjectFile *ELFObj =
331-
dyn_cast<ELF64BEObjectFile>(&**ElfOrErr))
332-
return findSymbolInImageImpl(*ELFObj, Name);
333-
return createError("Only 64-bit ELF files are supported");
334-
}

0 commit comments

Comments
 (0)