LLVM  15.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"
14 #include "llvm/Object/ELFTypes.h"
15 #include "llvm/Support/Errc.h"
16 #include "llvm/Support/Error.h"
20 
22 
23 using namespace llvm;
24 using namespace llvm::object;
25 using namespace llvm::ELF;
26 
27 namespace llvm {
28 namespace ifs {
29 
30 // Simple struct to hold relevant .dynamic entries.
32  uint64_t StrTabAddr = 0;
33  uint64_t StrSize = 0;
35  std::vector<uint64_t> NeededLibNames;
36  // Symbol table:
37  uint64_t DynSymAddr = 0;
38  // Hash tables:
41 };
42 
43 /// This initializes an ELF file header with information specific to a binary
44 /// dynamic shared object.
45 /// Offsets, indexes, links, etc. for section and program headers are just
46 /// zero-initialized as they will be updated elsewhere.
47 ///
48 /// @param ElfHeader Target ELFT::Ehdr to populate.
49 /// @param Machine Target architecture (e_machine from ELF specifications).
50 template <class ELFT>
51 static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine) {
52  memset(&ElfHeader, 0, sizeof(ElfHeader));
53  // ELF identification.
54  ElfHeader.e_ident[EI_MAG0] = ElfMagic[EI_MAG0];
55  ElfHeader.e_ident[EI_MAG1] = ElfMagic[EI_MAG1];
56  ElfHeader.e_ident[EI_MAG2] = ElfMagic[EI_MAG2];
57  ElfHeader.e_ident[EI_MAG3] = ElfMagic[EI_MAG3];
58  ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
59  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
60  ElfHeader.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
61  ElfHeader.e_ident[EI_VERSION] = EV_CURRENT;
62  ElfHeader.e_ident[EI_OSABI] = ELFOSABI_NONE;
63 
64  // Remainder of ELF header.
65  ElfHeader.e_type = ET_DYN;
66  ElfHeader.e_machine = Machine;
67  ElfHeader.e_version = EV_CURRENT;
68  ElfHeader.e_ehsize = sizeof(typename ELFT::Ehdr);
69  ElfHeader.e_phentsize = sizeof(typename ELFT::Phdr);
70  ElfHeader.e_shentsize = sizeof(typename ELFT::Shdr);
71 }
72 
73 namespace {
74 template <class ELFT> struct OutputSection {
75  using Elf_Shdr = typename ELFT::Shdr;
76  std::string Name;
77  Elf_Shdr Shdr;
79  uint64_t Offset;
80  uint64_t Size;
82  uint32_t Index;
83  bool NoBits = true;
84 };
85 
86 template <class T, class ELFT>
87 struct ContentSection : public OutputSection<ELFT> {
89  ContentSection() { this->NoBits = false; }
90 };
91 
92 // This class just wraps StringTableBuilder for the purpose of adding a
93 // default constructor.
94 class ELFStringTableBuilder : public StringTableBuilder {
95 public:
96  ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
97 };
98 
99 template <class ELFT> class ELFSymbolTableBuilder {
100 public:
101  using Elf_Sym = typename ELFT::Sym;
102 
103  ELFSymbolTableBuilder() { Symbols.push_back({}); }
104 
105  void add(size_t StNameOffset, uint64_t StSize, uint8_t StBind, uint8_t StType,
106  uint8_t StOther, uint16_t StShndx) {
107  Elf_Sym S{};
108  S.st_name = StNameOffset;
109  S.st_size = StSize;
110  S.st_info = (StBind << 4) | (StType & 0xf);
111  S.st_other = StOther;
112  S.st_shndx = StShndx;
113  Symbols.push_back(S);
114  }
115 
116  size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }
117 
118  void write(uint8_t *Buf) const {
119  memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
120  }
121 
122 private:
124 };
125 
126 template <class ELFT> class ELFDynamicTableBuilder {
127 public:
128  using Elf_Dyn = typename ELFT::Dyn;
129 
130  size_t addAddr(uint64_t Tag, uint64_t Addr) {
131  Elf_Dyn Entry;
132  Entry.d_tag = Tag;
133  Entry.d_un.d_ptr = Addr;
134  Entries.push_back(Entry);
135  return Entries.size() - 1;
136  }
137 
138  void modifyAddr(size_t Index, uint64_t Addr) {
139  Entries[Index].d_un.d_ptr = Addr;
140  }
141 
142  size_t addValue(uint64_t Tag, uint64_t Value) {
143  Elf_Dyn Entry;
144  Entry.d_tag = Tag;
145  Entry.d_un.d_val = Value;
146  Entries.push_back(Entry);
147  return Entries.size() - 1;
148  }
149 
150  void modifyValue(size_t Index, uint64_t Value) {
151  Entries[Index].d_un.d_val = Value;
152  }
153 
154  size_t getSize() const {
155  // Add DT_NULL entry at the end.
156  return (Entries.size() + 1) * sizeof(Elf_Dyn);
157  }
158 
159  void write(uint8_t *Buf) const {
160  memcpy(Buf, Entries.data(), sizeof(Elf_Dyn) * Entries.size());
161  // Add DT_NULL entry at the end.
162  memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));
163  }
164 
165 private:
167 };
168 
169 template <class ELFT> class ELFStubBuilder {
170 public:
171  using Elf_Ehdr = typename ELFT::Ehdr;
172  using Elf_Shdr = typename ELFT::Shdr;
173  using Elf_Phdr = typename ELFT::Phdr;
174  using Elf_Sym = typename ELFT::Sym;
175  using Elf_Addr = typename ELFT::Addr;
176  using Elf_Dyn = typename ELFT::Dyn;
177 
178  ELFStubBuilder(const ELFStubBuilder &) = delete;
179  ELFStubBuilder(ELFStubBuilder &&) = default;
180 
181  explicit ELFStubBuilder(const IFSStub &Stub) {
182  DynSym.Name = ".dynsym";
183  DynSym.Align = sizeof(Elf_Addr);
184  DynStr.Name = ".dynstr";
185  DynStr.Align = 1;
186  DynTab.Name = ".dynamic";
187  DynTab.Align = sizeof(Elf_Addr);
188  ShStrTab.Name = ".shstrtab";
189  ShStrTab.Align = 1;
190 
191  // Populate string tables.
192  for (const IFSSymbol &Sym : Stub.Symbols)
193  DynStr.Content.add(Sym.Name);
194  for (const std::string &Lib : Stub.NeededLibs)
195  DynStr.Content.add(Lib);
196  if (Stub.SoName)
197  DynStr.Content.add(Stub.SoName.getValue());
198 
199  std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,
200  &ShStrTab};
201  const OutputSection<ELFT> *LastSection = Sections.back();
202  // Now set the Index and put sections names into ".shstrtab".
203  uint64_t Index = 1;
204  for (OutputSection<ELFT> *Sec : Sections) {
205  Sec->Index = Index++;
206  ShStrTab.Content.add(Sec->Name);
207  }
208  ShStrTab.Content.finalize();
209  ShStrTab.Size = ShStrTab.Content.getSize();
210  DynStr.Content.finalize();
211  DynStr.Size = DynStr.Content.getSize();
212 
213  // Populate dynamic symbol table.
214  for (const IFSSymbol &Sym : Stub.Symbols) {
215  uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
216  // For non-undefined symbols, value of the shndx is not relevant at link
217  // time as long as it is not SHN_UNDEF. Set shndx to 1, which
218  // points to ".dynsym".
219  uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
220  uint64_t Size = Sym.Size ? *Sym.Size : 0;
221  DynSym.Content.add(DynStr.Content.getOffset(Sym.Name), Size, Bind,
222  convertIFSSymbolTypeToELF(Sym.Type), 0, Shndx);
223  }
224  DynSym.Size = DynSym.Content.getSize();
225 
226  // Poplulate dynamic table.
227  size_t DynSymIndex = DynTab.Content.addAddr(DT_SYMTAB, 0);
228  size_t DynStrIndex = DynTab.Content.addAddr(DT_STRTAB, 0);
229  DynTab.Content.addValue(DT_STRSZ, DynSym.Size);
230  for (const std::string &Lib : Stub.NeededLibs)
231  DynTab.Content.addValue(DT_NEEDED, DynStr.Content.getOffset(Lib));
232  if (Stub.SoName)
233  DynTab.Content.addValue(DT_SONAME,
234  DynStr.Content.getOffset(Stub.SoName.getValue()));
235  DynTab.Size = DynTab.Content.getSize();
236  // Calculate sections' addresses and offsets.
237  uint64_t CurrentOffset = sizeof(Elf_Ehdr);
238  for (OutputSection<ELFT> *Sec : Sections) {
239  Sec->Offset = alignTo(CurrentOffset, Sec->Align);
240  Sec->Addr = Sec->Offset;
241  CurrentOffset = Sec->Offset + Sec->Size;
242  }
243  // Fill Addr back to dynamic table.
244  DynTab.Content.modifyAddr(DynSymIndex, DynSym.Addr);
245  DynTab.Content.modifyAddr(DynStrIndex, DynStr.Addr);
246  // Write section headers of string tables.
247  fillSymTabShdr(DynSym, SHT_DYNSYM);
248  fillStrTabShdr(DynStr, SHF_ALLOC);
249  fillDynTabShdr(DynTab);
250  fillStrTabShdr(ShStrTab);
251 
252  // Finish initializing the ELF header.
253  initELFHeader<ELFT>(ElfHeader,
254  static_cast<uint16_t>(Stub.Target.Arch.getValue()));
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 
277 private:
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.
346 Error 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 
355 template <class ELFT> class DynSym {
356  using Elf_Shdr_Range = typename ELFT::ShdrRange;
357  using Elf_Shdr = typename ELFT::Shdr;
358 
359 public:
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 
385 private:
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.
429 static Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
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.
446 template <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.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) {
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) {
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.
519 template <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.
546 template <class ELFT>
547 static 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.
574 template <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.hasValue()) {
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.
656 template <class ELFT>
657 static 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.
712 Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub,
713  bool WriteIfChanged) {
714  assert(Stub.Target.Arch);
715  assert(Stub.Target.BitWidth);
716  assert(Stub.Target.Endianness);
717  if (Stub.Target.BitWidth == IFSBitWidthType::IFS32) {
718  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
719  return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
720  } else {
721  return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
722  }
723  } else {
724  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
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
llvm::Check::Size
@ Size
Definition: FileCheck.h:76
MemoryBuffer.h
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
llvm::errc::invalid_argument
@ invalid_argument
MathExtras.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
WriteIfChanged
static cl::opt< bool > WriteIfChanged("write-if-changed", cl::desc("Only write output if it changed"))
llvm::ELF::EI_DATA
@ EI_DATA
Definition: ELF.h:53
llvm::ifs::IFSSymbol
Definition: IFSStub.h:52
T
llvm::ifs::DynamicEntries::DynSymAddr
uint64_t DynSymAddr
Definition: ELFObjHandler.cpp:37
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:632
llvm::write
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:536
llvm::StringRef::npos
static constexpr size_t npos
Definition: StringRef.h:60
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::ifs::convertIFSSymbolTypeToELF
uint8_t convertIFSSymbolTypeToELF(IFSSymbolType SymbolType)
This function convert symbol type from IFS enum to ELF format Currently, STT_NOTYPE,...
Definition: IFSStub.cpp:83
llvm::ifs::IFSTarget::Arch
Optional< IFSArch > Arch
Definition: IFSStub.h:67
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
Content
T Content
Definition: ELFObjHandler.cpp:88
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:899
Error.h
llvm::ifs::terminatedSubstr
static Expected< StringRef > terminatedSubstr(StringRef Str, size_t Offset)
This function behaves similarly to StringRef::substr(), but attempts to terminate the returned String...
Definition: ELFObjHandler.cpp:429
Errc.h
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:948
llvm::Optional< uint64_t >
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1026
FileOutputBuffer.h
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:105
llvm::ifs::DynamicEntries::ElfHash
Optional< uint64_t > ElfHash
Definition: ELFObjHandler.cpp:39
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::ELF
Definition: ELF.h:27
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::ifs::convertELFSymbolTypeToIFS
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
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:931
llvm::ifs::buildStub
static Expected< std::unique_ptr< IFSStub > > buildStub(const ELFObjectFile< ELFT > &ElfObj)
Returns a new IFSStub with all members populated from an ELFObjectFile.
Definition: ELFObjHandler.cpp:576
ELFObjHandler.h
llvm::SubDirectoryType::Bin
@ Bin
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:283
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1181
llvm::MemoryBuffer::getFile
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Definition: MemoryBuffer.cpp:239
StringTableBuilder.h
llvm::ELF::ELFOSABI_NONE
@ ELFOSABI_NONE
Definition: ELF.h:341
llvm::ifs::DynamicEntries::StrSize
uint64_t StrSize
Definition: ELFObjHandler.cpp:33
llvm::object
Definition: DWARFDebugLoc.h:25
llvm::objcopy::FileFormat::ELF
@ ELF
llvm::support::little
@ little
Definition: Endian.h:27
llvm::ifs::DynamicEntries
Definition: ELFObjHandler.cpp:31
llvm::object::ELFObjectFile::getELFFile
const ELFFile< ELFT > & getELFFile() const
Definition: ELFObjectFile.h:449
llvm::ELF::EI_MAG1
@ EI_MAG1
Definition: ELF.h:49
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::ifs::IFSStub
Definition: IFSStub.h:89
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:951
llvm::object::object_error::parse_failed
@ parse_failed
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1212
IFSStub.h
llvm::ifs::createELFSym
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...
Definition: ELFObjHandler.cpp:520
llvm::ifs::IFSTarget::BitWidth
Optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:70
llvm::ifs::convertELFEndiannessToIFS
IFSEndiannessType convertELFEndiannessToIFS(uint8_t Endianness)
This function extracts ELF endianness from e_ident[EI_DATA] of an ELF file Currently,...
Definition: IFSStub.cpp:108
llvm::ELF::EI_OSABI
@ EI_OSABI
Definition: ELF.h:55
llvm::ELF::ET_DYN
@ ET_DYN
Definition: ELF.h:118
uint64_t
llvm::ifs::DynamicEntries::NeededLibNames
std::vector< uint64_t > NeededLibNames
Definition: ELFObjHandler.cpp:35
llvm::ELF::EI_CLASS
@ EI_CLASS
Definition: ELF.h:52
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:78
llvm::ifs::convertELFBitWidthToIFS
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
llvm::ARM_AM::add
@ add
Definition: ARMAddressingModes.h:39
llvm::ifs::DynamicEntries::GnuHash
Optional< uint64_t > GnuHash
Definition: ELFObjHandler.cpp:40
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::ELF::EV_CURRENT
@ EV_CURRENT
Definition: ELF.h:127
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:956
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::SPIRV::Decoration::Stream
@ Stream
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
ELFTypes.h
llvm::ifs::writeBinaryStub
Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub, bool WriteIfChanged=false)
Attempt to write a binary ELF stub.
Definition: ELFObjHandler.cpp:712
NoBits
bool NoBits
Definition: ELFObjHandler.cpp:83
llvm::ifs::DynamicEntries::StrTabAddr
uint64_t StrTabAddr
Definition: ELFObjHandler.cpp:32
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::ifs::initELFHeader
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.
Definition: ELFObjHandler.cpp:51
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1180
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition: ELF.h:1209
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::ELF::ELFDATA2LSB
@ ELFDATA2LSB
Definition: ELF.h:335
llvm::object::Binary
Definition: Binary.h:32
llvm::errc::not_supported
@ not_supported
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:567
uint32_t
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::FileOutputBuffer::create
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...
Definition: FileOutputBuffer.cpp:156
ELFObjectFile.h
llvm::ELF::EI_VERSION
@ EI_VERSION
Definition: ELF.h:54
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1239
uint16_t
llvm::ELF::EI_MAG0
@ EI_MAG0
Definition: ELF.h:48
llvm::ifs::IFSStub::Target
IFSTarget Target
Definition: IFSStub.h:93
llvm::toString
const char * toString(DWARFSectionKind Kind)
Definition: DWARFUnitIndex.h:67
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::ELF::ELFDATA2MSB
@ ELFDATA2MSB
Definition: ELF.h:336
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition: StringTableBuilder.h:23
llvm::ifs::IFSStub::Symbols
std::vector< IFSSymbol > Symbols
Definition: IFSStub.h:95
llvm::ifs::writeELFBinaryToFile
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.
Definition: ELFObjHandler.cpp:657
llvm::ELF::ElfMagic
static const char ElfMagic[]
Definition: ELF.h:44
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
Binary.h
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:369
llvm::ifs::populateSymbols
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.
Definition: ELFObjHandler.cpp:547
llvm::ifs::DynamicEntries::SONameOffset
Optional< uint64_t > SONameOffset
Definition: ELFObjHandler.cpp:34
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::ELF::ELFCLASS64
@ ELFCLASS64
Definition: ELF.h:329
llvm::object::createBinary
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:44
llvm::ELF::EI_MAG2
@ EI_MAG2
Definition: ELF.h:50
llvm::object::createError
Error createError(const Twine &Err)
Definition: Error.h:83
llvm::ifs::readELFFile
Expected< std::unique_ptr< IFSStub > > readELFFile(MemoryBufferRef Buf)
Attempt to read a binary ELF file from a MemoryBuffer.
Definition: ELFObjHandler.cpp:691
Name
std::string Name
Definition: ELFObjHandler.cpp:76
llvm::ELF::ELFCLASS32
@ ELFCLASS32
Definition: ELF.h:328
llvm::ifs::IFSTarget::Endianness
Optional< IFSEndiannessType > Endianness
Definition: IFSStub.h:69
llvm::object::ELFObjectFile
Definition: ELFObjectFile.h:240
llvm::ifs::populateDynamic
static Error populateDynamic(DynamicEntries &Dyn, typename ELFT::DynRange DynTable)
This function populates a DynamicEntries struct using an ELFT::DynRange.
Definition: ELFObjHandler.cpp:447
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::object::ELFFile
Definition: ELF.h:94
llvm::ELF::EI_MAG3
@ EI_MAG3
Definition: ELF.h:51
Shdr
Elf_Shdr Shdr
Definition: ELFObjHandler.cpp:77
llvm::dyn_cast
decltype(auto) LLVM_NODISCARD dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition: Casting.h:600