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;
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);
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.value_or(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));
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, static_cast<uint16_t>(*Stub.Target.Arch));
254  ElfHeader.e_shstrndx = ShStrTab.Index;
255  ElfHeader.e_shnum = LastSection->Index + 1;
256  ElfHeader.e_shoff =
257  alignTo(LastSection->Offset + LastSection->Size, sizeof(Elf_Addr));
258  }
259 
260  size_t getSize() const {
261  return ElfHeader.e_shoff + ElfHeader.e_shnum * sizeof(Elf_Shdr);
262  }
263 
264  void write(uint8_t *Data) const {
265  write(Data, ElfHeader);
266  DynSym.Content.write(Data + DynSym.Shdr.sh_offset);
267  DynStr.Content.write(Data + DynStr.Shdr.sh_offset);
268  DynTab.Content.write(Data + DynTab.Shdr.sh_offset);
269  ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
270  writeShdr(Data, DynSym);
271  writeShdr(Data, DynStr);
272  writeShdr(Data, DynTab);
273  writeShdr(Data, ShStrTab);
274  }
275 
276 private:
277  Elf_Ehdr ElfHeader;
278  ContentSection<ELFStringTableBuilder, ELFT> DynStr;
279  ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;
280  ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> DynSym;
281  ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> DynTab;
282 
283  template <class T> static void write(uint8_t *Data, const T &Value) {
284  *reinterpret_cast<T *>(Data) = Value;
285  }
286 
287  void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,
288  uint32_t ShFlags = 0) const {
289  StrTab.Shdr.sh_type = SHT_STRTAB;
290  StrTab.Shdr.sh_flags = ShFlags;
291  StrTab.Shdr.sh_addr = StrTab.Addr;
292  StrTab.Shdr.sh_offset = StrTab.Offset;
293  StrTab.Shdr.sh_info = 0;
294  StrTab.Shdr.sh_size = StrTab.Size;
295  StrTab.Shdr.sh_name = ShStrTab.Content.getOffset(StrTab.Name);
296  StrTab.Shdr.sh_addralign = StrTab.Align;
297  StrTab.Shdr.sh_entsize = 0;
298  StrTab.Shdr.sh_link = 0;
299  }
300  void fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> &SymTab,
301  uint32_t ShType) const {
302  SymTab.Shdr.sh_type = ShType;
303  SymTab.Shdr.sh_flags = SHF_ALLOC;
304  SymTab.Shdr.sh_addr = SymTab.Addr;
305  SymTab.Shdr.sh_offset = SymTab.Offset;
306  // Only non-local symbols are included in the tbe file, so .dynsym only
307  // contains 1 local symbol (the undefined symbol at index 0). The sh_info
308  // should always be 1.
309  SymTab.Shdr.sh_info = 1;
310  SymTab.Shdr.sh_size = SymTab.Size;
311  SymTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(SymTab.Name);
312  SymTab.Shdr.sh_addralign = SymTab.Align;
313  SymTab.Shdr.sh_entsize = sizeof(Elf_Sym);
314  SymTab.Shdr.sh_link = this->DynStr.Index;
315  }
316  void fillDynTabShdr(
317  ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> &DynTab) const {
318  DynTab.Shdr.sh_type = SHT_DYNAMIC;
319  DynTab.Shdr.sh_flags = SHF_ALLOC;
320  DynTab.Shdr.sh_addr = DynTab.Addr;
321  DynTab.Shdr.sh_offset = DynTab.Offset;
322  DynTab.Shdr.sh_info = 0;
323  DynTab.Shdr.sh_size = DynTab.Size;
324  DynTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(DynTab.Name);
325  DynTab.Shdr.sh_addralign = DynTab.Align;
326  DynTab.Shdr.sh_entsize = sizeof(Elf_Dyn);
327  DynTab.Shdr.sh_link = this->DynStr.Index;
328  }
329  uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const {
330  return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr);
331  }
332 
333  void writeShdr(uint8_t *Data, const OutputSection<ELFT> &Sec) const {
334  write(Data + shdrOffset(Sec), Sec.Shdr);
335  }
336 };
337 
338 /// This function takes an error, and appends a string of text to the end of
339 /// that error. Since "appending" to an Error isn't supported behavior of an
340 /// Error, this function technically creates a new error with the combined
341 /// message and consumes the old error.
342 ///
343 /// @param Err Source error.
344 /// @param After Text to append at the end of Err's error message.
345 Error appendToError(Error Err, StringRef After) {
346  std::string Message;
347  raw_string_ostream Stream(Message);
348  Stream << Err;
349  Stream << " " << After;
350  consumeError(std::move(Err));
351  return createError(Stream.str());
352 }
353 
354 template <class ELFT> class DynSym {
355  using Elf_Shdr_Range = typename ELFT::ShdrRange;
356  using Elf_Shdr = typename ELFT::Shdr;
357 
358 public:
359  static Expected<DynSym> create(const ELFFile<ELFT> &ElfFile,
360  const DynamicEntries &DynEnt) {
361  Expected<Elf_Shdr_Range> Shdrs = ElfFile.sections();
362  if (!Shdrs)
363  return Shdrs.takeError();
364  return DynSym(ElfFile, DynEnt, *Shdrs);
365  }
366 
367  Expected<const uint8_t *> getDynSym() {
368  if (DynSymHdr)
369  return ElfFile.base() + DynSymHdr->sh_offset;
370  return getDynamicData(DynEnt.DynSymAddr, "dynamic symbol table");
371  }
372 
373  Expected<StringRef> getDynStr() {
374  if (DynSymHdr)
375  return ElfFile.getStringTableForSymtab(*DynSymHdr, Shdrs);
376  Expected<const uint8_t *> DataOrErr = getDynamicData(
377  DynEnt.StrTabAddr, "dynamic string table", DynEnt.StrSize);
378  if (!DataOrErr)
379  return DataOrErr.takeError();
380  return StringRef(reinterpret_cast<const char *>(*DataOrErr),
381  DynEnt.StrSize);
382  }
383 
384 private:
385  DynSym(const ELFFile<ELFT> &ElfFile, const DynamicEntries &DynEnt,
386  Elf_Shdr_Range Shdrs)
387  : ElfFile(ElfFile), DynEnt(DynEnt), Shdrs(Shdrs),
388  DynSymHdr(findDynSymHdr()) {}
389 
390  const Elf_Shdr *findDynSymHdr() {
391  for (const Elf_Shdr &Sec : Shdrs)
392  if (Sec.sh_type == SHT_DYNSYM) {
393  // If multiple .dynsym are present, use the first one.
394  // This behavior aligns with llvm::object::ELFFile::getDynSymtabSize()
395  return &Sec;
396  }
397  return nullptr;
398  }
399 
400  Expected<const uint8_t *> getDynamicData(uint64_t EntAddr, StringRef Name,
401  uint64_t Size = 0) {
402  Expected<const uint8_t *> SecPtr = ElfFile.toMappedAddr(EntAddr);
403  if (!SecPtr)
404  return appendToError(
405  SecPtr.takeError(),
406  ("when locating " + Name + " section contents").str());
407  Expected<const uint8_t *> SecEndPtr = ElfFile.toMappedAddr(EntAddr + Size);
408  if (!SecEndPtr)
409  return appendToError(
410  SecEndPtr.takeError(),
411  ("when locating " + Name + " section contents").str());
412  return *SecPtr;
413  }
414 
415  const ELFFile<ELFT> &ElfFile;
416  const DynamicEntries &DynEnt;
417  Elf_Shdr_Range Shdrs;
418  const Elf_Shdr *DynSymHdr;
419 };
420 } // end anonymous namespace
421 
422 /// This function behaves similarly to StringRef::substr(), but attempts to
423 /// terminate the returned StringRef at the first null terminator. If no null
424 /// terminator is found, an error is returned.
425 ///
426 /// @param Str Source string to create a substring from.
427 /// @param Offset The start index of the desired substring.
428 static Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
429  size_t StrEnd = Str.find('\0', Offset);
430  if (StrEnd == StringLiteral::npos) {
431  return createError(
432  "String overran bounds of string table (no null terminator)");
433  }
434 
435  size_t StrLen = StrEnd - Offset;
436  return Str.substr(Offset, StrLen);
437 }
438 
439 /// This function populates a DynamicEntries struct using an ELFT::DynRange.
440 /// After populating the struct, the members are validated with
441 /// some basic correctness checks.
442 ///
443 /// @param Dyn Target DynamicEntries struct to populate.
444 /// @param DynTable Source dynamic table.
445 template <class ELFT>
447  typename ELFT::DynRange DynTable) {
448  if (DynTable.empty())
449  return createError("No .dynamic section found");
450 
451  // Search .dynamic for relevant entries.
452  bool FoundDynStr = false;
453  bool FoundDynStrSz = false;
454  bool FoundDynSym = false;
455  for (auto &Entry : DynTable) {
456  switch (Entry.d_tag) {
457  case DT_SONAME:
458  Dyn.SONameOffset = Entry.d_un.d_val;
459  break;
460  case DT_STRTAB:
461  Dyn.StrTabAddr = Entry.d_un.d_ptr;
462  FoundDynStr = true;
463  break;
464  case DT_STRSZ:
465  Dyn.StrSize = Entry.d_un.d_val;
466  FoundDynStrSz = true;
467  break;
468  case DT_NEEDED:
469  Dyn.NeededLibNames.push_back(Entry.d_un.d_val);
470  break;
471  case DT_SYMTAB:
472  Dyn.DynSymAddr = Entry.d_un.d_ptr;
473  FoundDynSym = true;
474  break;
475  case DT_HASH:
476  Dyn.ElfHash = Entry.d_un.d_ptr;
477  break;
478  case DT_GNU_HASH:
479  Dyn.GnuHash = Entry.d_un.d_ptr;
480  }
481  }
482 
483  if (!FoundDynStr) {
484  return createError(
485  "Couldn't locate dynamic string table (no DT_STRTAB entry)");
486  }
487  if (!FoundDynStrSz) {
488  return createError(
489  "Couldn't determine dynamic string table size (no DT_STRSZ entry)");
490  }
491  if (!FoundDynSym) {
492  return createError(
493  "Couldn't locate dynamic symbol table (no DT_SYMTAB entry)");
494  }
495  if (Dyn.SONameOffset && *Dyn.SONameOffset >= Dyn.StrSize) {
497  "DT_SONAME string offset (0x%016" PRIx64
498  ") outside of dynamic string table",
499  *Dyn.SONameOffset);
500  }
501  for (uint64_t Offset : Dyn.NeededLibNames) {
502  if (Offset >= Dyn.StrSize) {
504  "DT_NEEDED string offset (0x%016" PRIx64
505  ") outside of dynamic string table",
506  Offset);
507  }
508  }
509 
510  return Error::success();
511 }
512 
513 /// This function creates an IFSSymbol and populates all members using
514 /// information from a binary ELFT::Sym.
515 ///
516 /// @param SymName The desired name of the IFSSymbol.
517 /// @param RawSym ELFT::Sym to extract symbol information from.
518 template <class ELFT>
520  const typename ELFT::Sym &RawSym) {
521  IFSSymbol TargetSym{std::string(SymName)};
522  uint8_t Binding = RawSym.getBinding();
523  if (Binding == STB_WEAK)
524  TargetSym.Weak = true;
525  else
526  TargetSym.Weak = false;
527 
528  TargetSym.Undefined = RawSym.isUndefined();
529  TargetSym.Type = convertELFSymbolTypeToIFS(RawSym.st_info);
530 
531  if (TargetSym.Type == IFSSymbolType::Func) {
532  TargetSym.Size = 0;
533  } else {
534  TargetSym.Size = RawSym.st_size;
535  }
536  return TargetSym;
537 }
538 
539 /// This function populates an IFSStub with symbols using information read
540 /// from an ELF binary.
541 ///
542 /// @param TargetStub IFSStub to add symbols to.
543 /// @param DynSym Range of dynamic symbols to add to TargetStub.
544 /// @param DynStr StringRef to the dynamic string table.
545 template <class ELFT>
546 static Error populateSymbols(IFSStub &TargetStub,
547  const typename ELFT::SymRange DynSym,
548  StringRef DynStr) {
549  // Skips the first symbol since it's the NULL symbol.
550  for (auto RawSym : DynSym.drop_front(1)) {
551  // If a symbol does not have global or weak binding, ignore it.
552  uint8_t Binding = RawSym.getBinding();
553  if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
554  continue;
555  // If a symbol doesn't have default or protected visibility, ignore it.
556  uint8_t Visibility = RawSym.getVisibility();
557  if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
558  continue;
559  // Create an IFSSymbol and populate it with information from the symbol
560  // table entry.
561  Expected<StringRef> SymName = terminatedSubstr(DynStr, RawSym.st_name);
562  if (!SymName)
563  return SymName.takeError();
564  IFSSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
565  TargetStub.Symbols.push_back(std::move(Sym));
566  // TODO: Populate symbol warning.
567  }
568  return Error::success();
569 }
570 
571 /// Returns a new IFSStub with all members populated from an ELFObjectFile.
572 /// @param ElfObj Source ELFObjectFile.
573 template <class ELFT>
576  using Elf_Dyn_Range = typename ELFT::DynRange;
577  using Elf_Sym_Range = typename ELFT::SymRange;
578  using Elf_Sym = typename ELFT::Sym;
579  std::unique_ptr<IFSStub> DestStub = std::make_unique<IFSStub>();
580  const ELFFile<ELFT> &ElfFile = ElfObj.getELFFile();
581  // Fetch .dynamic table.
582  Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();
583  if (!DynTable) {
584  return DynTable.takeError();
585  }
586 
587  // Collect relevant .dynamic entries.
588  DynamicEntries DynEnt;
589  if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
590  return std::move(Err);
591  Expected<DynSym<ELFT>> EDynSym = DynSym<ELFT>::create(ElfFile, DynEnt);
592  if (!EDynSym)
593  return EDynSym.takeError();
594 
595  Expected<StringRef> EDynStr = EDynSym->getDynStr();
596  if (!EDynStr)
597  return EDynStr.takeError();
598 
599  StringRef DynStr = *EDynStr;
600 
601  // Populate Arch from ELF header.
602  DestStub->Target.Arch = static_cast<IFSArch>(ElfFile.getHeader().e_machine);
603  DestStub->Target.BitWidth =
604  convertELFBitWidthToIFS(ElfFile.getHeader().e_ident[EI_CLASS]);
605  DestStub->Target.Endianness =
606  convertELFEndiannessToIFS(ElfFile.getHeader().e_ident[EI_DATA]);
607  DestStub->Target.ObjectFormat = "ELF";
608 
609  // Populate SoName from .dynamic entries and dynamic string table.
610  if (DynEnt.SONameOffset) {
611  Expected<StringRef> NameOrErr =
612  terminatedSubstr(DynStr, *DynEnt.SONameOffset);
613  if (!NameOrErr) {
614  return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
615  }
616  DestStub->SoName = std::string(*NameOrErr);
617  }
618 
619  // Populate NeededLibs from .dynamic entries and dynamic string table.
620  for (uint64_t NeededStrOffset : DynEnt.NeededLibNames) {
621  Expected<StringRef> LibNameOrErr =
622  terminatedSubstr(DynStr, NeededStrOffset);
623  if (!LibNameOrErr) {
624  return appendToError(LibNameOrErr.takeError(), "when reading DT_NEEDED");
625  }
626  DestStub->NeededLibs.push_back(std::string(*LibNameOrErr));
627  }
628 
629  // Populate Symbols from .dynsym table and dynamic string table.
630  Expected<uint64_t> SymCount = ElfFile.getDynSymtabSize();
631  if (!SymCount)
632  return SymCount.takeError();
633  if (*SymCount > 0) {
634  // Get pointer to in-memory location of .dynsym section.
635  Expected<const uint8_t *> DynSymPtr = EDynSym->getDynSym();
636  if (!DynSymPtr)
637  return appendToError(DynSymPtr.takeError(),
638  "when locating .dynsym section contents");
639  Elf_Sym_Range DynSyms = ArrayRef<Elf_Sym>(
640  reinterpret_cast<const Elf_Sym *>(*DynSymPtr), *SymCount);
641  Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);
642  if (SymReadError)
643  return appendToError(std::move(SymReadError),
644  "when reading dynamic symbols");
645  }
646 
647  return std::move(DestStub);
648 }
649 
650 /// This function opens a file for writing and then writes a binary ELF stub to
651 /// the file.
652 ///
653 /// @param FilePath File path for writing the ELF binary.
654 /// @param Stub Source InterFace Stub to generate a binary ELF stub from.
655 template <class ELFT>
656 static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
657  bool WriteIfChanged) {
658  ELFStubBuilder<ELFT> Builder{Stub};
659  // Write Stub to memory first.
660  std::vector<uint8_t> Buf(Builder.getSize());
661  Builder.write(Buf.data());
662 
663  if (WriteIfChanged) {
664  if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
665  MemoryBuffer::getFile(FilePath)) {
666  // Compare Stub output with existing Stub file.
667  // If Stub file unchanged, abort updating.
668  if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
669  !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
670  Builder.getSize()))
671  return Error::success();
672  }
673  }
674 
676  FileOutputBuffer::create(FilePath, Builder.getSize());
677  if (!BufOrError)
679  toString(BufOrError.takeError()) +
680  " when trying to open `" + FilePath +
681  "` for writing");
682 
683  // Write binary to file.
684  std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
685  memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
686 
687  return FileBuf->commit();
688 }
689 
692  if (!BinOrErr) {
693  return BinOrErr.takeError();
694  }
695 
696  Binary *Bin = BinOrErr->get();
697  if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
698  return buildStub(*Obj);
699  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
700  return buildStub(*Obj);
701  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
702  return buildStub(*Obj);
703  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
704  return buildStub(*Obj);
705  }
706  return createStringError(errc::not_supported, "unsupported binary format");
707 }
708 
709 // This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
710 // can be called without having to use ELFType templates directly.
711 Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub,
712  bool WriteIfChanged) {
713  assert(Stub.Target.Arch);
714  assert(Stub.Target.BitWidth);
715  assert(Stub.Target.Endianness);
716  if (Stub.Target.BitWidth == IFSBitWidthType::IFS32) {
717  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
718  return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
719  } else {
720  return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
721  }
722  } else {
723  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
724  return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
725  } else {
726  return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
727  }
728  }
729  llvm_unreachable("invalid binary output target");
730 }
731 
732 } // end namespace ifs
733 } // end namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
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:156
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
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:428
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:957
Errc.h
llvm::Optional< uint64_t >
T
#define T
Definition: Mips16ISelLowering.cpp:341
FileOutputBuffer.h
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1035
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::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:575
ELFObjHandler.h
llvm::SubDirectoryType::Bin
@ Bin
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::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1189
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::object::object_error::parse_failed
@ parse_failed
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition: ELF.h:1218
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
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:519
llvm::ifs::IFSTarget::BitWidth
Optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:70
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:960
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
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:711
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::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
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::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1221
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:656
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:965
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
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:940
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:546
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:45
llvm::ELF::EI_MAG2
@ EI_MAG2
Definition: ELF.h:50
llvm::object::createError
Error createError(const Twine &Err)
Definition: Error.h:84
llvm::ifs::readELFFile
Expected< std::unique_ptr< IFSStub > > readELFFile(MemoryBufferRef Buf)
Attempt to read a binary ELF file from a MemoryBuffer.
Definition: ELFObjHandler.cpp:690
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:446
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
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1190
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:597