LLVM 17.0.0git
ELFObjHandler.cpp
Go to the documentation of this file.
1//===- ELFObjHandler.cpp --------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===-----------------------------------------------------------------------===/
8
12#include "llvm/Object/Binary.h"
15#include "llvm/Support/Errc.h"
16#include "llvm/Support/Error.h"
20#include <optional>
21
23
24using namespace llvm;
25using namespace llvm::object;
26using namespace llvm::ELF;
27
28namespace llvm {
29namespace ifs {
30
31// Simple struct to hold relevant .dynamic entries.
35 std::optional<uint64_t> SONameOffset;
36 std::vector<uint64_t> NeededLibNames;
37 // Symbol table:
39 // Hash tables:
40 std::optional<uint64_t> ElfHash;
41 std::optional<uint64_t> GnuHash;
42};
43
44/// This initializes an ELF file header with information specific to a binary
45/// dynamic shared object.
46/// Offsets, indexes, links, etc. for section and program headers are just
47/// zero-initialized as they will be updated elsewhere.
48///
49/// @param ElfHeader Target ELFT::Ehdr to populate.
50/// @param Machine Target architecture (e_machine from ELF specifications).
51template <class ELFT>
52static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine) {
53 memset(&ElfHeader, 0, sizeof(ElfHeader));
54 // ELF identification.
55 ElfHeader.e_ident[EI_MAG0] = ElfMagic[EI_MAG0];
56 ElfHeader.e_ident[EI_MAG1] = ElfMagic[EI_MAG1];
57 ElfHeader.e_ident[EI_MAG2] = ElfMagic[EI_MAG2];
58 ElfHeader.e_ident[EI_MAG3] = ElfMagic[EI_MAG3];
59 ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
60 bool IsLittleEndian = ELFT::TargetEndianness == support::little;
61 ElfHeader.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
62 ElfHeader.e_ident[EI_VERSION] = EV_CURRENT;
63 ElfHeader.e_ident[EI_OSABI] = ELFOSABI_NONE;
64
65 // Remainder of ELF header.
66 ElfHeader.e_type = ET_DYN;
67 ElfHeader.e_machine = Machine;
68 ElfHeader.e_version = EV_CURRENT;
69 ElfHeader.e_ehsize = sizeof(typename ELFT::Ehdr);
70 ElfHeader.e_phentsize = sizeof(typename ELFT::Phdr);
71 ElfHeader.e_shentsize = sizeof(typename ELFT::Shdr);
72}
73
74namespace {
75template <class ELFT> struct OutputSection {
76 using Elf_Shdr = typename ELFT::Shdr;
77 std::string Name;
78 Elf_Shdr Shdr;
80 uint64_t Offset;
84 bool NoBits = true;
85};
86
87template <class T, class ELFT>
88struct ContentSection : public OutputSection<ELFT> {
90 ContentSection() { this->NoBits = false; }
91};
92
93// This class just wraps StringTableBuilder for the purpose of adding a
94// default constructor.
95class ELFStringTableBuilder : public StringTableBuilder {
96public:
97 ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
98};
99
100template <class ELFT> class ELFSymbolTableBuilder {
101public:
102 using Elf_Sym = typename ELFT::Sym;
103
104 ELFSymbolTableBuilder() { Symbols.push_back({}); }
105
106 void add(size_t StNameOffset, uint64_t StSize, uint8_t StBind, uint8_t StType,
107 uint8_t StOther, uint16_t StShndx) {
108 Elf_Sym S{};
109 S.st_name = StNameOffset;
110 S.st_size = StSize;
111 S.st_info = (StBind << 4) | (StType & 0xf);
112 S.st_other = StOther;
113 S.st_shndx = StShndx;
114 Symbols.push_back(S);
115 }
116
117 size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }
118
119 void write(uint8_t *Buf) const {
120 memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
121 }
122
123private:
125};
126
127template <class ELFT> class ELFDynamicTableBuilder {
128public:
129 using Elf_Dyn = typename ELFT::Dyn;
130
131 size_t addAddr(uint64_t Tag, uint64_t Addr) {
132 Elf_Dyn Entry;
133 Entry.d_tag = Tag;
134 Entry.d_un.d_ptr = Addr;
135 Entries.push_back(Entry);
136 return Entries.size() - 1;
137 }
138
139 void modifyAddr(size_t Index, uint64_t Addr) {
140 Entries[Index].d_un.d_ptr = Addr;
141 }
142
143 size_t addValue(uint64_t Tag, uint64_t Value) {
144 Elf_Dyn Entry;
145 Entry.d_tag = Tag;
146 Entry.d_un.d_val = Value;
147 Entries.push_back(Entry);
148 return Entries.size() - 1;
149 }
150
151 void modifyValue(size_t Index, uint64_t Value) {
152 Entries[Index].d_un.d_val = Value;
153 }
154
155 size_t getSize() const {
156 // Add DT_NULL entry at the end.
157 return (Entries.size() + 1) * sizeof(Elf_Dyn);
158 }
159
160 void write(uint8_t *Buf) const {
161 memcpy(Buf, Entries.data(), sizeof(Elf_Dyn) * Entries.size());
162 // Add DT_NULL entry at the end.
163 memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));
164 }
165
166private:
168};
169
170template <class ELFT> class ELFStubBuilder {
171public:
172 using Elf_Ehdr = typename ELFT::Ehdr;
173 using Elf_Shdr = typename ELFT::Shdr;
174 using Elf_Phdr = typename ELFT::Phdr;
175 using Elf_Sym = typename ELFT::Sym;
176 using Elf_Addr = typename ELFT::Addr;
177 using Elf_Dyn = typename ELFT::Dyn;
178
179 ELFStubBuilder(const ELFStubBuilder &) = delete;
180 ELFStubBuilder(ELFStubBuilder &&) = default;
181
182 explicit ELFStubBuilder(const IFSStub &Stub) {
183 DynSym.Name = ".dynsym";
184 DynSym.Align = sizeof(Elf_Addr);
185 DynStr.Name = ".dynstr";
186 DynStr.Align = 1;
187 DynTab.Name = ".dynamic";
188 DynTab.Align = sizeof(Elf_Addr);
189 ShStrTab.Name = ".shstrtab";
190 ShStrTab.Align = 1;
191
192 // Populate string tables.
193 for (const IFSSymbol &Sym : Stub.Symbols)
194 DynStr.Content.add(Sym.Name);
195 for (const std::string &Lib : Stub.NeededLibs)
196 DynStr.Content.add(Lib);
197 if (Stub.SoName)
198 DynStr.Content.add(*Stub.SoName);
199
200 std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,
201 &ShStrTab};
202 const OutputSection<ELFT> *LastSection = Sections.back();
203 // Now set the Index and put sections names into ".shstrtab".
204 uint64_t Index = 1;
205 for (OutputSection<ELFT> *Sec : Sections) {
206 Sec->Index = Index++;
207 ShStrTab.Content.add(Sec->Name);
208 }
209 ShStrTab.Content.finalize();
210 ShStrTab.Size = ShStrTab.Content.getSize();
211 DynStr.Content.finalize();
212 DynStr.Size = DynStr.Content.getSize();
213
214 // Populate dynamic symbol table.
215 for (const IFSSymbol &Sym : Stub.Symbols) {
216 uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
217 // For non-undefined symbols, value of the shndx is not relevant at link
218 // time as long as it is not SHN_UNDEF. Set shndx to 1, which
219 // points to ".dynsym".
220 uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
221 uint64_t Size = Sym.Size.value_or(0);
222 DynSym.Content.add(DynStr.Content.getOffset(Sym.Name), Size, Bind,
223 convertIFSSymbolTypeToELF(Sym.Type), 0, Shndx);
224 }
225 DynSym.Size = DynSym.Content.getSize();
226
227 // Poplulate dynamic table.
228 size_t DynSymIndex = DynTab.Content.addAddr(DT_SYMTAB, 0);
229 size_t DynStrIndex = DynTab.Content.addAddr(DT_STRTAB, 0);
230 DynTab.Content.addValue(DT_STRSZ, DynSym.Size);
231 for (const std::string &Lib : Stub.NeededLibs)
232 DynTab.Content.addValue(DT_NEEDED, DynStr.Content.getOffset(Lib));
233 if (Stub.SoName)
234 DynTab.Content.addValue(DT_SONAME,
235 DynStr.Content.getOffset(*Stub.SoName));
236 DynTab.Size = DynTab.Content.getSize();
237 // Calculate sections' addresses and offsets.
238 uint64_t CurrentOffset = sizeof(Elf_Ehdr);
239 for (OutputSection<ELFT> *Sec : Sections) {
240 Sec->Offset = alignTo(CurrentOffset, Sec->Align);
241 Sec->Addr = Sec->Offset;
242 CurrentOffset = Sec->Offset + Sec->Size;
243 }
244 // Fill Addr back to dynamic table.
245 DynTab.Content.modifyAddr(DynSymIndex, DynSym.Addr);
246 DynTab.Content.modifyAddr(DynStrIndex, DynStr.Addr);
247 // Write section headers of string tables.
248 fillSymTabShdr(DynSym, SHT_DYNSYM);
249 fillStrTabShdr(DynStr, SHF_ALLOC);
250 fillDynTabShdr(DynTab);
251 fillStrTabShdr(ShStrTab);
252
253 // Finish initializing the ELF header.
254 initELFHeader<ELFT>(ElfHeader, static_cast<uint16_t>(*Stub.Target.Arch));
255 ElfHeader.e_shstrndx = ShStrTab.Index;
256 ElfHeader.e_shnum = LastSection->Index + 1;
257 ElfHeader.e_shoff =
258 alignTo(LastSection->Offset + LastSection->Size, sizeof(Elf_Addr));
259 }
260
261 size_t getSize() const {
262 return ElfHeader.e_shoff + ElfHeader.e_shnum * sizeof(Elf_Shdr);
263 }
264
265 void write(uint8_t *Data) const {
266 write(Data, ElfHeader);
267 DynSym.Content.write(Data + DynSym.Shdr.sh_offset);
268 DynStr.Content.write(Data + DynStr.Shdr.sh_offset);
269 DynTab.Content.write(Data + DynTab.Shdr.sh_offset);
270 ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
271 writeShdr(Data, DynSym);
272 writeShdr(Data, DynStr);
273 writeShdr(Data, DynTab);
274 writeShdr(Data, ShStrTab);
275 }
276
277private:
278 Elf_Ehdr ElfHeader;
279 ContentSection<ELFStringTableBuilder, ELFT> DynStr;
280 ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;
281 ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> DynSym;
282 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> DynTab;
283
284 template <class T> static void write(uint8_t *Data, const T &Value) {
285 *reinterpret_cast<T *>(Data) = Value;
286 }
287
288 void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,
289 uint32_t ShFlags = 0) const {
290 StrTab.Shdr.sh_type = SHT_STRTAB;
291 StrTab.Shdr.sh_flags = ShFlags;
292 StrTab.Shdr.sh_addr = StrTab.Addr;
293 StrTab.Shdr.sh_offset = StrTab.Offset;
294 StrTab.Shdr.sh_info = 0;
295 StrTab.Shdr.sh_size = StrTab.Size;
296 StrTab.Shdr.sh_name = ShStrTab.Content.getOffset(StrTab.Name);
297 StrTab.Shdr.sh_addralign = StrTab.Align;
298 StrTab.Shdr.sh_entsize = 0;
299 StrTab.Shdr.sh_link = 0;
300 }
301 void fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> &SymTab,
302 uint32_t ShType) const {
303 SymTab.Shdr.sh_type = ShType;
304 SymTab.Shdr.sh_flags = SHF_ALLOC;
305 SymTab.Shdr.sh_addr = SymTab.Addr;
306 SymTab.Shdr.sh_offset = SymTab.Offset;
307 // Only non-local symbols are included in the tbe file, so .dynsym only
308 // contains 1 local symbol (the undefined symbol at index 0). The sh_info
309 // should always be 1.
310 SymTab.Shdr.sh_info = 1;
311 SymTab.Shdr.sh_size = SymTab.Size;
312 SymTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(SymTab.Name);
313 SymTab.Shdr.sh_addralign = SymTab.Align;
314 SymTab.Shdr.sh_entsize = sizeof(Elf_Sym);
315 SymTab.Shdr.sh_link = this->DynStr.Index;
316 }
317 void fillDynTabShdr(
318 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> &DynTab) const {
319 DynTab.Shdr.sh_type = SHT_DYNAMIC;
320 DynTab.Shdr.sh_flags = SHF_ALLOC;
321 DynTab.Shdr.sh_addr = DynTab.Addr;
322 DynTab.Shdr.sh_offset = DynTab.Offset;
323 DynTab.Shdr.sh_info = 0;
324 DynTab.Shdr.sh_size = DynTab.Size;
325 DynTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(DynTab.Name);
326 DynTab.Shdr.sh_addralign = DynTab.Align;
327 DynTab.Shdr.sh_entsize = sizeof(Elf_Dyn);
328 DynTab.Shdr.sh_link = this->DynStr.Index;
329 }
330 uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const {
331 return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr);
332 }
333
334 void writeShdr(uint8_t *Data, const OutputSection<ELFT> &Sec) const {
335 write(Data + shdrOffset(Sec), Sec.Shdr);
336 }
337};
338
339/// This function takes an error, and appends a string of text to the end of
340/// that error. Since "appending" to an Error isn't supported behavior of an
341/// Error, this function technically creates a new error with the combined
342/// message and consumes the old error.
343///
344/// @param Err Source error.
345/// @param After Text to append at the end of Err's error message.
346Error appendToError(Error Err, StringRef After) {
347 std::string Message;
348 raw_string_ostream Stream(Message);
349 Stream << Err;
350 Stream << " " << After;
351 consumeError(std::move(Err));
352 return createError(Stream.str());
353}
354
355template <class ELFT> class DynSym {
356 using Elf_Shdr_Range = typename ELFT::ShdrRange;
357 using Elf_Shdr = typename ELFT::Shdr;
358
359public:
360 static Expected<DynSym> create(const ELFFile<ELFT> &ElfFile,
361 const DynamicEntries &DynEnt) {
362 Expected<Elf_Shdr_Range> Shdrs = ElfFile.sections();
363 if (!Shdrs)
364 return Shdrs.takeError();
365 return DynSym(ElfFile, DynEnt, *Shdrs);
366 }
367
368 Expected<const uint8_t *> getDynSym() {
369 if (DynSymHdr)
370 return ElfFile.base() + DynSymHdr->sh_offset;
371 return getDynamicData(DynEnt.DynSymAddr, "dynamic symbol table");
372 }
373
374 Expected<StringRef> getDynStr() {
375 if (DynSymHdr)
376 return ElfFile.getStringTableForSymtab(*DynSymHdr, Shdrs);
377 Expected<const uint8_t *> DataOrErr = getDynamicData(
378 DynEnt.StrTabAddr, "dynamic string table", DynEnt.StrSize);
379 if (!DataOrErr)
380 return DataOrErr.takeError();
381 return StringRef(reinterpret_cast<const char *>(*DataOrErr),
382 DynEnt.StrSize);
383 }
384
385private:
386 DynSym(const ELFFile<ELFT> &ElfFile, const DynamicEntries &DynEnt,
387 Elf_Shdr_Range Shdrs)
388 : ElfFile(ElfFile), DynEnt(DynEnt), Shdrs(Shdrs),
389 DynSymHdr(findDynSymHdr()) {}
390
391 const Elf_Shdr *findDynSymHdr() {
392 for (const Elf_Shdr &Sec : Shdrs)
393 if (Sec.sh_type == SHT_DYNSYM) {
394 // If multiple .dynsym are present, use the first one.
395 // This behavior aligns with llvm::object::ELFFile::getDynSymtabSize()
396 return &Sec;
397 }
398 return nullptr;
399 }
400
401 Expected<const uint8_t *> getDynamicData(uint64_t EntAddr, StringRef Name,
402 uint64_t Size = 0) {
403 Expected<const uint8_t *> SecPtr = ElfFile.toMappedAddr(EntAddr);
404 if (!SecPtr)
405 return appendToError(
406 SecPtr.takeError(),
407 ("when locating " + Name + " section contents").str());
408 Expected<const uint8_t *> SecEndPtr = ElfFile.toMappedAddr(EntAddr + Size);
409 if (!SecEndPtr)
410 return appendToError(
411 SecEndPtr.takeError(),
412 ("when locating " + Name + " section contents").str());
413 return *SecPtr;
414 }
415
416 const ELFFile<ELFT> &ElfFile;
417 const DynamicEntries &DynEnt;
418 Elf_Shdr_Range Shdrs;
419 const Elf_Shdr *DynSymHdr;
420};
421} // end anonymous namespace
422
423/// This function behaves similarly to StringRef::substr(), but attempts to
424/// terminate the returned StringRef at the first null terminator. If no null
425/// terminator is found, an error is returned.
426///
427/// @param Str Source string to create a substring from.
428/// @param Offset The start index of the desired substring.
430 size_t StrEnd = Str.find('\0', Offset);
431 if (StrEnd == StringLiteral::npos) {
432 return createError(
433 "String overran bounds of string table (no null terminator)");
434 }
435
436 size_t StrLen = StrEnd - Offset;
437 return Str.substr(Offset, StrLen);
438}
439
440/// This function populates a DynamicEntries struct using an ELFT::DynRange.
441/// After populating the struct, the members are validated with
442/// some basic correctness checks.
443///
444/// @param Dyn Target DynamicEntries struct to populate.
445/// @param DynTable Source dynamic table.
446template <class ELFT>
448 typename ELFT::DynRange DynTable) {
449 if (DynTable.empty())
450 return createError("No .dynamic section found");
451
452 // Search .dynamic for relevant entries.
453 bool FoundDynStr = false;
454 bool FoundDynStrSz = false;
455 bool FoundDynSym = false;
456 for (auto &Entry : DynTable) {
457 switch (Entry.d_tag) {
458 case DT_SONAME:
459 Dyn.SONameOffset = Entry.d_un.d_val;
460 break;
461 case DT_STRTAB:
462 Dyn.StrTabAddr = Entry.d_un.d_ptr;
463 FoundDynStr = true;
464 break;
465 case DT_STRSZ:
466 Dyn.StrSize = Entry.d_un.d_val;
467 FoundDynStrSz = true;
468 break;
469 case DT_NEEDED:
470 Dyn.NeededLibNames.push_back(Entry.d_un.d_val);
471 break;
472 case DT_SYMTAB:
473 Dyn.DynSymAddr = Entry.d_un.d_ptr;
474 FoundDynSym = true;
475 break;
476 case DT_HASH:
477 Dyn.ElfHash = Entry.d_un.d_ptr;
478 break;
479 case DT_GNU_HASH:
480 Dyn.GnuHash = Entry.d_un.d_ptr;
481 }
482 }
483
484 if (!FoundDynStr) {
485 return createError(
486 "Couldn't locate dynamic string table (no DT_STRTAB entry)");
487 }
488 if (!FoundDynStrSz) {
489 return createError(
490 "Couldn't determine dynamic string table size (no DT_STRSZ entry)");
491 }
492 if (!FoundDynSym) {
493 return createError(
494 "Couldn't locate dynamic symbol table (no DT_SYMTAB entry)");
495 }
496 if (Dyn.SONameOffset && *Dyn.SONameOffset >= Dyn.StrSize) {
497 return createStringError(object_error::parse_failed,
498 "DT_SONAME string offset (0x%016" PRIx64
499 ") outside of dynamic string table",
500 *Dyn.SONameOffset);
501 }
502 for (uint64_t Offset : Dyn.NeededLibNames) {
503 if (Offset >= Dyn.StrSize) {
504 return createStringError(object_error::parse_failed,
505 "DT_NEEDED string offset (0x%016" PRIx64
506 ") outside of dynamic string table",
507 Offset);
508 }
509 }
510
511 return Error::success();
512}
513
514/// This function creates an IFSSymbol and populates all members using
515/// information from a binary ELFT::Sym.
516///
517/// @param SymName The desired name of the IFSSymbol.
518/// @param RawSym ELFT::Sym to extract symbol information from.
519template <class ELFT>
521 const typename ELFT::Sym &RawSym) {
522 IFSSymbol TargetSym{std::string(SymName)};
523 uint8_t Binding = RawSym.getBinding();
524 if (Binding == STB_WEAK)
525 TargetSym.Weak = true;
526 else
527 TargetSym.Weak = false;
528
529 TargetSym.Undefined = RawSym.isUndefined();
530 TargetSym.Type = convertELFSymbolTypeToIFS(RawSym.st_info);
531
532 if (TargetSym.Type == IFSSymbolType::Func) {
533 TargetSym.Size = 0;
534 } else {
535 TargetSym.Size = RawSym.st_size;
536 }
537 return TargetSym;
538}
539
540/// This function populates an IFSStub with symbols using information read
541/// from an ELF binary.
542///
543/// @param TargetStub IFSStub to add symbols to.
544/// @param DynSym Range of dynamic symbols to add to TargetStub.
545/// @param DynStr StringRef to the dynamic string table.
546template <class ELFT>
547static Error populateSymbols(IFSStub &TargetStub,
548 const typename ELFT::SymRange DynSym,
549 StringRef DynStr) {
550 // Skips the first symbol since it's the NULL symbol.
551 for (auto RawSym : DynSym.drop_front(1)) {
552 // If a symbol does not have global or weak binding, ignore it.
553 uint8_t Binding = RawSym.getBinding();
554 if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
555 continue;
556 // If a symbol doesn't have default or protected visibility, ignore it.
557 uint8_t Visibility = RawSym.getVisibility();
558 if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
559 continue;
560 // Create an IFSSymbol and populate it with information from the symbol
561 // table entry.
562 Expected<StringRef> SymName = terminatedSubstr(DynStr, RawSym.st_name);
563 if (!SymName)
564 return SymName.takeError();
565 IFSSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
566 TargetStub.Symbols.push_back(std::move(Sym));
567 // TODO: Populate symbol warning.
568 }
569 return Error::success();
570}
571
572/// Returns a new IFSStub with all members populated from an ELFObjectFile.
573/// @param ElfObj Source ELFObjectFile.
574template <class ELFT>
577 using Elf_Dyn_Range = typename ELFT::DynRange;
578 using Elf_Sym_Range = typename ELFT::SymRange;
579 using Elf_Sym = typename ELFT::Sym;
580 std::unique_ptr<IFSStub> DestStub = std::make_unique<IFSStub>();
581 const ELFFile<ELFT> &ElfFile = ElfObj.getELFFile();
582 // Fetch .dynamic table.
583 Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();
584 if (!DynTable) {
585 return DynTable.takeError();
586 }
587
588 // Collect relevant .dynamic entries.
589 DynamicEntries DynEnt;
590 if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
591 return std::move(Err);
592 Expected<DynSym<ELFT>> EDynSym = DynSym<ELFT>::create(ElfFile, DynEnt);
593 if (!EDynSym)
594 return EDynSym.takeError();
595
596 Expected<StringRef> EDynStr = EDynSym->getDynStr();
597 if (!EDynStr)
598 return EDynStr.takeError();
599
600 StringRef DynStr = *EDynStr;
601
602 // Populate Arch from ELF header.
603 DestStub->Target.Arch = static_cast<IFSArch>(ElfFile.getHeader().e_machine);
604 DestStub->Target.BitWidth =
605 convertELFBitWidthToIFS(ElfFile.getHeader().e_ident[EI_CLASS]);
606 DestStub->Target.Endianness =
607 convertELFEndiannessToIFS(ElfFile.getHeader().e_ident[EI_DATA]);
608 DestStub->Target.ObjectFormat = "ELF";
609
610 // Populate SoName from .dynamic entries and dynamic string table.
611 if (DynEnt.SONameOffset) {
612 Expected<StringRef> NameOrErr =
613 terminatedSubstr(DynStr, *DynEnt.SONameOffset);
614 if (!NameOrErr) {
615 return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
616 }
617 DestStub->SoName = std::string(*NameOrErr);
618 }
619
620 // Populate NeededLibs from .dynamic entries and dynamic string table.
621 for (uint64_t NeededStrOffset : DynEnt.NeededLibNames) {
622 Expected<StringRef> LibNameOrErr =
623 terminatedSubstr(DynStr, NeededStrOffset);
624 if (!LibNameOrErr) {
625 return appendToError(LibNameOrErr.takeError(), "when reading DT_NEEDED");
626 }
627 DestStub->NeededLibs.push_back(std::string(*LibNameOrErr));
628 }
629
630 // Populate Symbols from .dynsym table and dynamic string table.
631 Expected<uint64_t> SymCount = ElfFile.getDynSymtabSize();
632 if (!SymCount)
633 return SymCount.takeError();
634 if (*SymCount > 0) {
635 // Get pointer to in-memory location of .dynsym section.
636 Expected<const uint8_t *> DynSymPtr = EDynSym->getDynSym();
637 if (!DynSymPtr)
638 return appendToError(DynSymPtr.takeError(),
639 "when locating .dynsym section contents");
640 Elf_Sym_Range DynSyms = ArrayRef<Elf_Sym>(
641 reinterpret_cast<const Elf_Sym *>(*DynSymPtr), *SymCount);
642 Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);
643 if (SymReadError)
644 return appendToError(std::move(SymReadError),
645 "when reading dynamic symbols");
646 }
647
648 return std::move(DestStub);
649}
650
651/// This function opens a file for writing and then writes a binary ELF stub to
652/// the file.
653///
654/// @param FilePath File path for writing the ELF binary.
655/// @param Stub Source InterFace Stub to generate a binary ELF stub from.
656template <class ELFT>
657static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
658 bool WriteIfChanged) {
659 ELFStubBuilder<ELFT> Builder{Stub};
660 // Write Stub to memory first.
661 std::vector<uint8_t> Buf(Builder.getSize());
662 Builder.write(Buf.data());
663
664 if (WriteIfChanged) {
665 if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
666 MemoryBuffer::getFile(FilePath)) {
667 // Compare Stub output with existing Stub file.
668 // If Stub file unchanged, abort updating.
669 if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
670 !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
671 Builder.getSize()))
672 return Error::success();
673 }
674 }
675
677 FileOutputBuffer::create(FilePath, Builder.getSize());
678 if (!BufOrError)
680 toString(BufOrError.takeError()) +
681 " when trying to open `" + FilePath +
682 "` for writing");
683
684 // Write binary to file.
685 std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
686 memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
687
688 return FileBuf->commit();
689}
690
693 if (!BinOrErr) {
694 return BinOrErr.takeError();
695 }
696
697 Binary *Bin = BinOrErr->get();
698 if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
699 return buildStub(*Obj);
700 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
701 return buildStub(*Obj);
702 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
703 return buildStub(*Obj);
704 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
705 return buildStub(*Obj);
706 }
707 return createStringError(errc::not_supported, "unsupported binary format");
708}
709
710// This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
711// can be called without having to use ELFType templates directly.
713 bool WriteIfChanged) {
714 assert(Stub.Target.Arch);
715 assert(Stub.Target.BitWidth);
719 return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
720 } else {
721 return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
722 }
723 } else {
725 return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
726 } else {
727 return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
728 }
729 }
730 llvm_unreachable("invalid binary output target");
731}
732
733} // end namespace ifs
734} // end namespace llvm
assume Assume Builder
T Content
Elf_Shdr Shdr
bool NoBits
uint64_t Addr
std::string Name
uint64_t Size
This supports reading and writing of elf dynamic shared objects.
This file defines an internal representation of an InterFace Stub.
static cl::opt< bool > WriteIfChanged("write-if-changed", cl::desc("Only write output if it changed"))
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:908
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static unsigned getSize(unsigned Kind)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Represents either an error or a value T.
Definition: ErrorOr.h:56
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static ErrorSuccess success()
Create a success value.
Definition: Error.h:330
Tagged union holding either a T or a Error.
Definition: Error.h:470
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
reference get()
Returns a reference to the stored T value.
Definition: Error.h:567
static Expected< std::unique_ptr< FileOutputBuffer > > create(StringRef FilePath, size_t Size, unsigned Flags=0)
Factory method to create an OutputBuffer object which manages a read/write buffer of the specified si...
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
static constexpr size_t npos
Definition: StringRef.h:52
Utility for building string tables with deduplicated suffixes.
LLVM Value Representation.
Definition: Value.h:74
const ELFFile< ELFT > & getELFFile() const
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ELF.h:27
@ SHF_ALLOC
Definition: ELF.h:1083
@ EV_CURRENT
Definition: ELF.h:127
@ STV_PROTECTED
Definition: ELF.h:1269
@ STV_DEFAULT
Definition: ELF.h:1266
@ ELFCLASS64
Definition: ELF.h:329
@ ELFCLASS32
Definition: ELF.h:328
@ ELFDATA2MSB
Definition: ELF.h:336
@ ELFDATA2LSB
Definition: ELF.h:335
@ SHN_UNDEF
Definition: ELF.h:980
static const char ElfMagic[]
Definition: ELF.h:44
@ SHT_STRTAB
Definition: ELF.h:997
@ SHT_DYNAMIC
Definition: ELF.h:1000
@ SHT_DYNSYM
Definition: ELF.h:1005
@ STB_GLOBAL
Definition: ELF.h:1237
@ STB_WEAK
Definition: ELF.h:1238
@ ET_DYN
Definition: ELF.h:118
@ ELFOSABI_NONE
Definition: ELF.h:341
@ EI_DATA
Definition: ELF.h:53
@ EI_MAG3
Definition: ELF.h:51
@ EI_MAG1
Definition: ELF.h:49
@ EI_VERSION
Definition: ELF.h:54
@ EI_MAG2
Definition: ELF.h:50
@ EI_MAG0
Definition: ELF.h:48
@ EI_CLASS
Definition: ELF.h:52
@ EI_OSABI
Definition: ELF.h:55
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub, bool WriteIfChanged)
This function opens a file for writing and then writes a binary ELF stub to the file.
Expected< std::unique_ptr< IFSStub > > readELFFile(MemoryBufferRef Buf)
Attempt to read a binary ELF file from a MemoryBuffer.
Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub, bool WriteIfChanged=false)
Attempt to write a binary ELF stub.
uint8_t convertIFSSymbolTypeToELF(IFSSymbolType SymbolType)
This function convert symbol type from IFS enum to ELF format Currently, STT_NOTYPE,...
Definition: IFSStub.cpp:83
static Expected< std::unique_ptr< IFSStub > > buildStub(const ELFObjectFile< ELFT > &ElfObj)
Returns a new IFSStub with all members populated from an ELFObjectFile.
static Error populateSymbols(IFSStub &TargetStub, const typename ELFT::SymRange DynSym, StringRef DynStr)
This function populates an IFSStub with symbols using information read from an ELF binary.
static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine)
This initializes an ELF file header with information specific to a binary dynamic shared object.
IFSBitWidthType convertELFBitWidthToIFS(uint8_t BitWidth)
This function extracts ELF bit width from e_ident[EI_CLASS] of an ELF file Currently,...
Definition: IFSStub.cpp:97
IFSEndiannessType convertELFEndiannessToIFS(uint8_t Endianness)
This function extracts ELF endianness from e_ident[EI_DATA] of an ELF file Currently,...
Definition: IFSStub.cpp:108
static Error populateDynamic(DynamicEntries &Dyn, typename ELFT::DynRange DynTable)
This function populates a DynamicEntries struct using an ELFT::DynRange.
static IFSSymbol createELFSym(StringRef SymName, const typename ELFT::Sym &RawSym)
This function creates an IFSSymbol and populates all members using information from a binary ELFT::Sy...
IFSSymbolType convertELFSymbolTypeToIFS(uint8_t SymbolType)
This function extracts symbol type from a symbol's st_info member and maps it to an IFSSymbolType enu...
Definition: IFSStub.cpp:119
static Expected< StringRef > terminatedSubstr(StringRef Str, size_t Offset)
This function behaves similarly to StringRef::substr(), but attempts to terminate the returned String...
Expected< std::unique_ptr< Binary > > createBinary(MemoryBufferRef Source, LLVMContext *Context=nullptr, bool InitContent=true)
Create a Binary from Source, autodetecting the file type.
Definition: Binary.cpp:45
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:406
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:551
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition: Casting.h:650
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1246
static Error createError(const Twine &Err)
Definition: APFloat.cpp:271
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
std::optional< uint64_t > ElfHash
std::vector< uint64_t > NeededLibNames
std::optional< uint64_t > GnuHash
std::optional< uint64_t > SONameOffset
std::vector< IFSSymbol > Symbols
Definition: IFSStub.h:95
IFSTarget Target
Definition: IFSStub.h:93
std::optional< IFSEndiannessType > Endianness
Definition: IFSStub.h:69
std::optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:70
std::optional< IFSArch > Arch
Definition: IFSStub.h:67