Skip to content

Commit 4c8714e

Browse files
uweiganduweigand
committed
Revert "[libomptarget] Support BE ELF files in plugins-nextgen (#85246)"
This reverts commit 611c62b.
1 parent 4e232ca commit 4c8714e

File tree

5 files changed

+50
-90
lines changed

5 files changed

+50
-90
lines changed

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -104,7 +104,7 @@ class GenericGlobalHandlerTy {
104104
virtual ~GenericGlobalHandlerTy() {}
105105

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

109109
/// Returns whether the symbol named \p SymName is present in the given \p
110110
/// Image.

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

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -28,15 +28,17 @@ bool isELF(llvm::StringRef Buffer);
2828
llvm::Expected<bool> checkMachine(llvm::StringRef Object, uint16_t EMachine);
2929

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

3435
/// Returns the symbol associated with the \p Name in the \p ELFObj. It will
3536
/// first search for the hash sections to identify symbols from the hash table.
3637
/// If that fails it will fall back to a linear search in the case of an
3738
/// executable file without a hash table.
38-
llvm::Expected<std::optional<llvm::object::ELFSymbolRef>>
39-
getSymbol(const llvm::object::ObjectFile &ELFObj, llvm::StringRef Name);
39+
llvm::Expected<const typename llvm::object::ELF64LE::Sym *>
40+
getSymbol(const llvm::object::ELFObjectFile<llvm::object::ELF64LE> &ELFObj,
41+
llvm::StringRef Name);
4042

4143
} // namespace elf
4244
} // namespace utils

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

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

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

33-
return ELFObjectFileBase::createELFObjectFile(Image.getMemoryBuffer());
33+
Expected<ELF64LEObjectFile> ElfOrErr =
34+
ELF64LEObjectFile::create(Image.getMemoryBuffer());
35+
return ElfOrErr;
3436
}
3537

3638
Error GenericGlobalHandlerTy::moveGlobalBetweenDeviceAndHost(
@@ -89,13 +91,13 @@ bool GenericGlobalHandlerTy::isSymbolInImage(GenericDeviceTy &Device,
8991
}
9092

9193
// Search the ELF symbol using the symbol name.
92-
auto SymOrErr = utils::elf::getSymbol(**ELFObjOrErr, SymName);
94+
auto SymOrErr = utils::elf::getSymbol(*ELFObjOrErr, SymName);
9395
if (!SymOrErr) {
9496
consumeError(SymOrErr.takeError());
9597
return false;
9698
}
9799

98-
return SymOrErr->has_value();
100+
return *SymOrErr;
99101
}
100102

101103
Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
@@ -108,7 +110,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
108110
return ELFObj.takeError();
109111

110112
// Search the ELF symbol using the symbol name.
111-
auto SymOrErr = utils::elf::getSymbol(**ELFObj, ImageGlobal.getName());
113+
auto SymOrErr = utils::elf::getSymbol(*ELFObj, ImageGlobal.getName());
112114
if (!SymOrErr)
113115
return Plugin::error("Failed ELF lookup of global '%s': %s",
114116
ImageGlobal.getName().data(),
@@ -118,7 +120,7 @@ Error GenericGlobalHandlerTy::getGlobalMetadataFromImage(
118120
return Plugin::error("Failed to find global symbol '%s' in the ELF image",
119121
ImageGlobal.getName().data());
120122

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

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

132134
return Plugin::success();
133135
}

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

Lines changed: 33 additions & 77 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,
@@ -149,10 +138,9 @@ getSymbolFromSysVHashTable(StringRef Name, const typename ELFT::Hash &HashTab,
149138
}
150139

151140
template <class ELFT>
152-
static Expected<std::optional<ELFSymbolRef>>
153-
getHashTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
154-
const typename ELFT::Shdr &Sec, StringRef Name) {
155-
const ELFFile<ELFT> &Elf = ELFObj.getELFFile();
141+
static Expected<const typename ELFT::Sym *>
142+
getHashTableSymbol(const ELFFile<ELFT> &Elf, const typename ELFT::Shdr &Sec,
143+
StringRef Name) {
156144
if (Sec.sh_type != ELF::SHT_HASH && Sec.sh_type != ELF::SHT_GNU_HASH)
157145
return createError(
158146
"invalid sh_type for hash table, expected SHT_HASH or SHT_GNU_HASH");
@@ -191,10 +179,7 @@ getHashTableSymbol(const ELFObjectFile<ELFT> &ELFObj,
191179
sizeof(typename ELFT::Word) * HashTab->nbuckets +
192180
sizeof(typename ELFT::Word) * (SymTab.size() - HashTab->symndx))
193181
return createError("section has invalid sh_size: " + Twine(Sec.sh_size));
194-
auto Sym = getSymbolFromGnuHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
195-
if (!Sym)
196-
return Sym.takeError();
197-
return ELFObj.toSymbolRef(*SymTabOrErr, *Sym - &SymTab[0]);
182+
return getSymbolFromGnuHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
198183
}
199184

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

215-
auto Sym = getSymbolFromSysVHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
216-
if (!Sym)
217-
return Sym.takeError();
218-
return ELFObj.toSymbolRef(*SymTabOrErr, *Sym - &SymTab[0]);
200+
return getSymbolFromSysVHashTable<ELFT>(Name, *HashTab, SymTab, StrTab);
219201
}
220202

221-
return std::nullopt;
203+
return nullptr;
222204
}
223205

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

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

250-
return std::nullopt;
231+
return nullptr;
251232
}
252233

253-
template <class ELFT>
254-
static Expected<std::optional<ELFSymbolRef>>
255-
getSymbolImpl(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
234+
Expected<const typename ELF64LE::Sym *>
235+
utils::elf::getSymbol(const ELFObjectFile<ELF64LE> &ELFObj, StringRef Name) {
256236
// First try to look up the symbol via the hash table.
257237
for (ELFSectionRef Sec : ELFObj.sections()) {
258238
if (Sec.getType() != SHT_HASH && Sec.getType() != SHT_GNU_HASH)
@@ -261,7 +241,8 @@ getSymbolImpl(const ELFObjectFile<ELFT> &ELFObj, StringRef Name) {
261241
auto HashTabOrErr = ELFObj.getELFFile().getSection(Sec.getIndex());
262242
if (!HashTabOrErr)
263243
return HashTabOrErr.takeError();
264-
return getHashTableSymbol<ELFT>(ELFObj, **HashTabOrErr, Name);
244+
return getHashTableSymbol<ELF64LE>(ELFObj.getELFFile(), **HashTabOrErr,
245+
Name);
265246
}
266247

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

278-
return std::nullopt;
279-
}
280-
281-
Expected<std::optional<ELFSymbolRef>>
282-
utils::elf::getSymbol(const ObjectFile &Obj, StringRef Name) {
283-
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj))
284-
return getSymbolImpl(*ELFObj, Name);
285-
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(&Obj))
286-
return getSymbolImpl(*ELFObj, Name);
287-
return createError("Only 64-bit ELF files are supported");
259+
return nullptr;
288260
}
289261

290-
template <class ELFT>
291-
static Expected<const void *>
292-
getSymbolAddressImpl(const ELFObjectFile<ELFT> &ELFObj,
293-
const ELFSymbolRef &SymRef) {
294-
const ELFFile<ELFT> &ELFFile = ELFObj.getELFFile();
295-
296-
auto SymOrErr = ELFObj.getSymbol(SymRef.getRawDataRefImpl());
297-
if (!SymOrErr)
298-
return SymOrErr.takeError();
299-
const auto &Symbol = **SymOrErr;
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();
300266

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

318284
return ELFFile.base() + Offset;
319285
}
320-
321-
Expected<const void *>
322-
utils::elf::getSymbolAddress(const ELFSymbolRef &SymRef) {
323-
const ObjectFile *Obj = SymRef.getObject();
324-
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
325-
return getSymbolAddressImpl(*ELFObj, SymRef);
326-
if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
327-
return getSymbolAddressImpl(*ELFObj, SymRef);
328-
return createError("Only 64-bit ELF files are supported");
329-
}

‎openmp/libomptarget/plugins-nextgen/cuda/src/rtl.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1166,7 +1166,7 @@ struct CUDADeviceTy : public GenericDeviceTy {
11661166

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

0 commit comments

Comments
 (0)