LLVM  14.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 #include "llvm/Support/Process.h"
21 
24 
25 using namespace llvm;
26 using namespace llvm::object;
27 using namespace llvm::ELF;
28 
29 namespace llvm {
30 namespace ifs {
31 
32 // Simple struct to hold relevant .dynamic entries.
34  uint64_t StrTabAddr = 0;
35  uint64_t StrSize = 0;
37  std::vector<uint64_t> NeededLibNames;
38  // Symbol table:
39  uint64_t DynSymAddr = 0;
40  // Hash tables:
43 };
44 
45 /// This initializes an ELF file header with information specific to a binary
46 /// dynamic shared object.
47 /// Offsets, indexes, links, etc. for section and program headers are just
48 /// zero-initialized as they will be updated elsewhere.
49 ///
50 /// @param ElfHeader Target ELFT::Ehdr to populate.
51 /// @param Machine Target architecture (e_machine from ELF specifications).
52 template <class ELFT>
53 static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine) {
54  memset(&ElfHeader, 0, sizeof(ElfHeader));
55  // ELF identification.
56  ElfHeader.e_ident[EI_MAG0] = ElfMagic[EI_MAG0];
57  ElfHeader.e_ident[EI_MAG1] = ElfMagic[EI_MAG1];
58  ElfHeader.e_ident[EI_MAG2] = ElfMagic[EI_MAG2];
59  ElfHeader.e_ident[EI_MAG3] = ElfMagic[EI_MAG3];
60  ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
61  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
62  ElfHeader.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
63  ElfHeader.e_ident[EI_VERSION] = EV_CURRENT;
64  ElfHeader.e_ident[EI_OSABI] = ELFOSABI_NONE;
65 
66  // Remainder of ELF header.
67  ElfHeader.e_type = ET_DYN;
68  ElfHeader.e_machine = Machine;
69  ElfHeader.e_version = EV_CURRENT;
70  ElfHeader.e_ehsize = sizeof(typename ELFT::Ehdr);
71  ElfHeader.e_phentsize = sizeof(typename ELFT::Phdr);
72  ElfHeader.e_shentsize = sizeof(typename ELFT::Shdr);
73 }
74 
75 namespace {
76 template <class ELFT> struct OutputSection {
77  using Elf_Shdr = typename ELFT::Shdr;
78  std::string Name;
79  Elf_Shdr Shdr;
80  uint64_t Addr;
81  uint64_t Offset;
82  uint64_t Size;
83  uint64_t Align;
85  bool NoBits = true;
86 };
87 
88 template <class T, class ELFT>
89 struct ContentSection : public OutputSection<ELFT> {
91  ContentSection() { this->NoBits = false; }
92 };
93 
94 // This class just wraps StringTableBuilder for the purpose of adding a
95 // default constructor.
96 class ELFStringTableBuilder : public StringTableBuilder {
97 public:
98  ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
99 };
100 
101 template <class ELFT> class ELFSymbolTableBuilder {
102 public:
103  using Elf_Sym = typename ELFT::Sym;
104 
105  ELFSymbolTableBuilder() { Symbols.push_back({}); }
106 
107  void add(size_t StNameOffset, uint64_t StSize, uint8_t StBind, uint8_t StType,
108  uint8_t StOther, uint16_t StShndx) {
109  Elf_Sym S{};
110  S.st_name = StNameOffset;
111  S.st_size = StSize;
112  S.st_info = (StBind << 4) | (StType & 0xf);
113  S.st_other = StOther;
114  S.st_shndx = StShndx;
115  Symbols.push_back(S);
116  }
117 
118  size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }
119 
120  void write(uint8_t *Buf) const {
121  memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
122  }
123 
124 private:
126 };
127 
128 template <class ELFT> class ELFDynamicTableBuilder {
129 public:
130  using Elf_Dyn = typename ELFT::Dyn;
131 
132  size_t addAddr(uint64_t Tag, uint64_t Addr) {
133  Elf_Dyn Entry;
134  Entry.d_tag = Tag;
135  Entry.d_un.d_ptr = Addr;
136  Entries.push_back(Entry);
137  return Entries.size() - 1;
138  }
139 
140  void modifyAddr(size_t Index, uint64_t Addr) {
141  Entries[Index].d_un.d_ptr = Addr;
142  }
143 
144  size_t addValue(uint64_t Tag, uint64_t Value) {
145  Elf_Dyn Entry;
146  Entry.d_tag = Tag;
147  Entry.d_un.d_val = Value;
148  Entries.push_back(Entry);
149  return Entries.size() - 1;
150  }
151 
152  void modifyValue(size_t Index, uint64_t Value) {
153  Entries[Index].d_un.d_val = Value;
154  }
155 
156  size_t getSize() const {
157  // Add DT_NULL entry at the end.
158  return (Entries.size() + 1) * sizeof(Elf_Dyn);
159  }
160 
161  void write(uint8_t *Buf) const {
162  memcpy(Buf, Entries.data(), sizeof(Elf_Dyn) * Entries.size());
163  // Add DT_NULL entry at the end.
164  memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));
165  }
166 
167 private:
169 };
170 
171 template <class ELFT> class ELFStubBuilder {
172 public:
173  using Elf_Ehdr = typename ELFT::Ehdr;
174  using Elf_Shdr = typename ELFT::Shdr;
175  using Elf_Phdr = typename ELFT::Phdr;
176  using Elf_Sym = typename ELFT::Sym;
177  using Elf_Addr = typename ELFT::Addr;
178  using Elf_Dyn = typename ELFT::Dyn;
179 
180  ELFStubBuilder(const ELFStubBuilder &) = delete;
181  ELFStubBuilder(ELFStubBuilder &&) = default;
182 
183  explicit ELFStubBuilder(const IFSStub &Stub) {
184  DynSym.Name = ".dynsym";
185  DynSym.Align = sizeof(Elf_Addr);
186  DynStr.Name = ".dynstr";
187  DynStr.Align = 1;
188  DynTab.Name = ".dynamic";
189  DynTab.Align = sizeof(Elf_Addr);
190  ShStrTab.Name = ".shstrtab";
191  ShStrTab.Align = 1;
192 
193  // Populate string tables.
194  for (const IFSSymbol &Sym : Stub.Symbols)
195  DynStr.Content.add(Sym.Name);
196  for (const std::string &Lib : Stub.NeededLibs)
197  DynStr.Content.add(Lib);
198  if (Stub.SoName)
199  DynStr.Content.add(Stub.SoName.getValue());
200 
201  std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,
202  &ShStrTab};
203  const OutputSection<ELFT> *LastSection = Sections.back();
204  // Now set the Index and put sections names into ".shstrtab".
205  uint64_t Index = 1;
206  for (OutputSection<ELFT> *Sec : Sections) {
207  Sec->Index = Index++;
208  ShStrTab.Content.add(Sec->Name);
209  }
210  ShStrTab.Content.finalize();
211  ShStrTab.Size = ShStrTab.Content.getSize();
212  DynStr.Content.finalize();
213  DynStr.Size = DynStr.Content.getSize();
214 
215  // Populate dynamic symbol table.
216  for (const IFSSymbol &Sym : Stub.Symbols) {
217  uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
218  // For non-undefined symbols, value of the shndx is not relevant at link
219  // time as long as it is not SHN_UNDEF. Set shndx to 1, which
220  // points to ".dynsym".
221  uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
222  DynSym.Content.add(DynStr.Content.getOffset(Sym.Name), Sym.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  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 } // end anonymous namespace
339 
340 /// This function behaves similarly to StringRef::substr(), but attempts to
341 /// terminate the returned StringRef at the first null terminator. If no null
342 /// terminator is found, an error is returned.
343 ///
344 /// @param Str Source string to create a substring from.
345 /// @param Offset The start index of the desired substring.
347  size_t StrEnd = Str.find('\0', Offset);
348  if (StrEnd == StringLiteral::npos) {
349  return createError(
350  "String overran bounds of string table (no null terminator)");
351  }
352 
353  size_t StrLen = StrEnd - Offset;
354  return Str.substr(Offset, StrLen);
355 }
356 
357 /// This function takes an error, and appends a string of text to the end of
358 /// that error. Since "appending" to an Error isn't supported behavior of an
359 /// Error, this function technically creates a new error with the combined
360 /// message and consumes the old error.
361 ///
362 /// @param Err Source error.
363 /// @param After Text to append at the end of Err's error message.
365  std::string Message;
366  raw_string_ostream Stream(Message);
367  Stream << Err;
368  Stream << " " << After;
369  consumeError(std::move(Err));
370  return createError(Stream.str().c_str());
371 }
372 
373 /// This function populates a DynamicEntries struct using an ELFT::DynRange.
374 /// After populating the struct, the members are validated with
375 /// some basic sanity checks.
376 ///
377 /// @param Dyn Target DynamicEntries struct to populate.
378 /// @param DynTable Source dynamic table.
379 template <class ELFT>
381  typename ELFT::DynRange DynTable) {
382  if (DynTable.empty())
383  return createError("No .dynamic section found");
384 
385  // Search .dynamic for relevant entries.
386  bool FoundDynStr = false;
387  bool FoundDynStrSz = false;
388  bool FoundDynSym = false;
389  for (auto &Entry : DynTable) {
390  switch (Entry.d_tag) {
391  case DT_SONAME:
392  Dyn.SONameOffset = Entry.d_un.d_val;
393  break;
394  case DT_STRTAB:
395  Dyn.StrTabAddr = Entry.d_un.d_ptr;
396  FoundDynStr = true;
397  break;
398  case DT_STRSZ:
399  Dyn.StrSize = Entry.d_un.d_val;
400  FoundDynStrSz = true;
401  break;
402  case DT_NEEDED:
403  Dyn.NeededLibNames.push_back(Entry.d_un.d_val);
404  break;
405  case DT_SYMTAB:
406  Dyn.DynSymAddr = Entry.d_un.d_ptr;
407  FoundDynSym = true;
408  break;
409  case DT_HASH:
410  Dyn.ElfHash = Entry.d_un.d_ptr;
411  break;
412  case DT_GNU_HASH:
413  Dyn.GnuHash = Entry.d_un.d_ptr;
414  }
415  }
416 
417  if (!FoundDynStr) {
418  return createError(
419  "Couldn't locate dynamic string table (no DT_STRTAB entry)");
420  }
421  if (!FoundDynStrSz) {
422  return createError(
423  "Couldn't determine dynamic string table size (no DT_STRSZ entry)");
424  }
425  if (!FoundDynSym) {
426  return createError(
427  "Couldn't locate dynamic symbol table (no DT_SYMTAB entry)");
428  }
429  if (Dyn.SONameOffset.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) {
431  "DT_SONAME string offset (0x%016" PRIx64
432  ") outside of dynamic string table",
433  *Dyn.SONameOffset);
434  }
435  for (uint64_t Offset : Dyn.NeededLibNames) {
436  if (Offset >= Dyn.StrSize) {
438  "DT_NEEDED string offset (0x%016" PRIx64
439  ") outside of dynamic string table",
440  Offset);
441  }
442  }
443 
444  return Error::success();
445 }
446 
447 /// This function creates an IFSSymbol and populates all members using
448 /// information from a binary ELFT::Sym.
449 ///
450 /// @param SymName The desired name of the IFSSymbol.
451 /// @param RawSym ELFT::Sym to extract symbol information from.
452 template <class ELFT>
454  const typename ELFT::Sym &RawSym) {
455  IFSSymbol TargetSym{std::string(SymName)};
456  uint8_t Binding = RawSym.getBinding();
457  if (Binding == STB_WEAK)
458  TargetSym.Weak = true;
459  else
460  TargetSym.Weak = false;
461 
462  TargetSym.Undefined = RawSym.isUndefined();
463  TargetSym.Type = convertELFSymbolTypeToIFS(RawSym.st_info);
464 
465  if (TargetSym.Type == IFSSymbolType::Func) {
466  TargetSym.Size = 0;
467  } else {
468  TargetSym.Size = RawSym.st_size;
469  }
470  return TargetSym;
471 }
472 
473 /// This function populates an IFSStub with symbols using information read
474 /// from an ELF binary.
475 ///
476 /// @param TargetStub IFSStub to add symbols to.
477 /// @param DynSym Range of dynamic symbols to add to TargetStub.
478 /// @param DynStr StringRef to the dynamic string table.
479 template <class ELFT>
480 static Error populateSymbols(IFSStub &TargetStub,
481  const typename ELFT::SymRange DynSym,
482  StringRef DynStr) {
483  // Skips the first symbol since it's the NULL symbol.
484  for (auto RawSym : DynSym.drop_front(1)) {
485  // If a symbol does not have global or weak binding, ignore it.
486  uint8_t Binding = RawSym.getBinding();
487  if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
488  continue;
489  // If a symbol doesn't have default or protected visibility, ignore it.
490  uint8_t Visibility = RawSym.getVisibility();
491  if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
492  continue;
493  // Create an IFSSymbol and populate it with information from the symbol
494  // table entry.
495  Expected<StringRef> SymName = terminatedSubstr(DynStr, RawSym.st_name);
496  if (!SymName)
497  return SymName.takeError();
498  IFSSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
499  TargetStub.Symbols.push_back(std::move(Sym));
500  // TODO: Populate symbol warning.
501  }
502  return Error::success();
503 }
504 
505 /// Returns a new IFSStub with all members populated from an ELFObjectFile.
506 /// @param ElfObj Source ELFObjectFile.
507 template <class ELFT>
510  using Elf_Dyn_Range = typename ELFT::DynRange;
511  using Elf_Phdr_Range = typename ELFT::PhdrRange;
512  using Elf_Sym_Range = typename ELFT::SymRange;
513  using Elf_Sym = typename ELFT::Sym;
514  std::unique_ptr<IFSStub> DestStub = std::make_unique<IFSStub>();
515  const ELFFile<ELFT> &ElfFile = ElfObj.getELFFile();
516  // Fetch .dynamic table.
517  Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();
518  if (!DynTable) {
519  return DynTable.takeError();
520  }
521 
522  // Fetch program headers.
523  Expected<Elf_Phdr_Range> PHdrs = ElfFile.program_headers();
524  if (!PHdrs) {
525  return PHdrs.takeError();
526  }
527 
528  // Collect relevant .dynamic entries.
529  DynamicEntries DynEnt;
530  if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
531  return std::move(Err);
532 
533  // Get pointer to in-memory location of .dynstr section.
534  Expected<const uint8_t *> DynStrPtr = ElfFile.toMappedAddr(DynEnt.StrTabAddr);
535  if (!DynStrPtr)
536  return appendToError(DynStrPtr.takeError(),
537  "when locating .dynstr section contents");
538 
539  StringRef DynStr(reinterpret_cast<const char *>(DynStrPtr.get()),
540  DynEnt.StrSize);
541 
542  // Populate Arch from ELF header.
543  DestStub->Target.Arch = static_cast<IFSArch>(ElfFile.getHeader().e_machine);
544  DestStub->Target.BitWidth =
545  convertELFBitWidthToIFS(ElfFile.getHeader().e_ident[EI_CLASS]);
546  DestStub->Target.Endianness =
547  convertELFEndiannessToIFS(ElfFile.getHeader().e_ident[EI_DATA]);
548  DestStub->Target.ObjectFormat = "ELF";
549 
550  // Populate SoName from .dynamic entries and dynamic string table.
551  if (DynEnt.SONameOffset.hasValue()) {
552  Expected<StringRef> NameOrErr =
553  terminatedSubstr(DynStr, *DynEnt.SONameOffset);
554  if (!NameOrErr) {
555  return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
556  }
557  DestStub->SoName = std::string(*NameOrErr);
558  }
559 
560  // Populate NeededLibs from .dynamic entries and dynamic string table.
561  for (uint64_t NeededStrOffset : DynEnt.NeededLibNames) {
562  Expected<StringRef> LibNameOrErr =
563  terminatedSubstr(DynStr, NeededStrOffset);
564  if (!LibNameOrErr) {
565  return appendToError(LibNameOrErr.takeError(), "when reading DT_NEEDED");
566  }
567  DestStub->NeededLibs.push_back(std::string(*LibNameOrErr));
568  }
569 
570  // Populate Symbols from .dynsym table and dynamic string table.
571  Expected<uint64_t> SymCount = ElfFile.getDynSymtabSize();
572  if (!SymCount)
573  return SymCount.takeError();
574  if (*SymCount > 0) {
575  // Get pointer to in-memory location of .dynsym section.
576  Expected<const uint8_t *> DynSymPtr =
577  ElfFile.toMappedAddr(DynEnt.DynSymAddr);
578  if (!DynSymPtr)
579  return appendToError(DynSymPtr.takeError(),
580  "when locating .dynsym section contents");
581  Elf_Sym_Range DynSyms = ArrayRef<Elf_Sym>(
582  reinterpret_cast<const Elf_Sym *>(*DynSymPtr), *SymCount);
583  Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);
584  if (SymReadError)
585  return appendToError(std::move(SymReadError),
586  "when reading dynamic symbols");
587  }
588 
589  return std::move(DestStub);
590 }
591 
592 /// This function opens a file for writing and then writes a binary ELF stub to
593 /// the file.
594 ///
595 /// @param FilePath File path for writing the ELF binary.
596 /// @param Stub Source InterFace Stub to generate a binary ELF stub from.
597 template <class ELFT>
598 static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub,
599  bool WriteIfChanged) {
600  ELFStubBuilder<ELFT> Builder{Stub};
601  // Write Stub to memory first.
602  std::vector<uint8_t> Buf(Builder.getSize());
603  Builder.write(Buf.data());
604 
605  if (WriteIfChanged) {
606  if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
607  MemoryBuffer::getFile(FilePath)) {
608  // Compare Stub output with existing Stub file.
609  // If Stub file unchanged, abort updating.
610  if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
611  !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
612  Builder.getSize()))
613  return Error::success();
614  }
615  }
616 
618  FileOutputBuffer::create(FilePath, Builder.getSize());
619  if (!BufOrError)
621  toString(BufOrError.takeError()) +
622  " when trying to open `" + FilePath +
623  "` for writing");
624 
625  // Write binary to file.
626  std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
627  memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
628 
629  return FileBuf->commit();
630 }
631 
634  if (!BinOrErr) {
635  return BinOrErr.takeError();
636  }
637 
638  Binary *Bin = BinOrErr->get();
639  if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
640  return buildStub(*Obj);
641  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
642  return buildStub(*Obj);
643  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
644  return buildStub(*Obj);
645  } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
646  return buildStub(*Obj);
647  }
648  return createStringError(errc::not_supported, "unsupported binary format");
649 }
650 
651 // This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
652 // can be called without having to use ELFType templates directly.
653 Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub,
654  bool WriteIfChanged) {
655  assert(Stub.Target.Arch);
656  assert(Stub.Target.BitWidth);
657  assert(Stub.Target.Endianness);
658  if (Stub.Target.BitWidth == IFSBitWidthType::IFS32) {
659  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
660  return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
661  } else {
662  return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
663  }
664  } else {
665  if (Stub.Target.Endianness == IFSEndiannessType::Little) {
666  return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
667  } else {
668  return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
669  }
670  }
671  llvm_unreachable("invalid binary output target");
672 }
673 
674 } // end namespace ifs
675 } // end namespace llvm
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
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::ifs::appendToError
Error appendToError(Error Err, StringRef After)
This function takes an error, and appends a string of text to the end of that error.
Definition: ELFObjHandler.cpp:364
WriteIfChanged
static cl::opt< bool > WriteIfChanged("write-if-changed", cl::desc("Only write output if it changed"))
llvm::ifs::IFSSymbol
Definition: IFSStub.h:53
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:912
llvm::ifs::DynamicEntries::DynSymAddr
uint64_t DynSymAddr
Definition: ELFObjHandler.cpp:39
llvm::ELF::ELFCLASS32
@ ELFCLASS32
Definition: ELF.h:328
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:623
llvm::write
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:535
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:1020
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:1168
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:68
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:331
llvm::object::createError
static Error createError(const Twine &Err)
Definition: ELF.h:84
Content
T Content
Definition: ELFObjHandler.cpp:90
memcmp
Merge contiguous icmps into a memcmp
Definition: MergeICmps.cpp:912
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:346
Errc.h
llvm::ELF::STB_GLOBAL
@ STB_GLOBAL
Definition: ELF.h:1139
llvm::dyn_cast
LLVM_NODISCARD std::enable_if_t< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type > dyn_cast(const Y &Val)
Definition: Casting.h:334
llvm::object::ELFFile::getDynSymtabSize
Expected< uint64_t > getDynSymtabSize() const
This function determines the number of dynamic symbols.
Definition: ELF.h:694
llvm::ELF::ELFDATA2LSB
@ ELFDATA2LSB
Definition: ELF.h:335
llvm::Optional< uint64_t >
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
FileOutputBuffer.h
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:104
llvm::ifs::DynamicEntries::ElfHash
Optional< uint64_t > ElfHash
Definition: ELFObjHandler.cpp:41
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1035
llvm::Data
@ Data
Definition: SIMachineScheduler.h:56
llvm::ELF
Definition: ELF.h:28
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:509
ELFObjHandler.h
llvm::Optional::hasValue
constexpr bool hasValue() const
Definition: Optional.h:288
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:246
StringTableBuilder.h
Process.h
llvm::ifs::DynamicEntries::StrSize
uint64_t StrSize
Definition: ELFObjHandler.cpp:35
llvm::object
Definition: ObjectFileTransformer.h:18
llvm::support::little
@ little
Definition: Endian.h:27
llvm::ifs::DynamicEntries
Definition: ELFObjHandler.cpp:33
llvm::object::ELFObjectFile::getELFFile
const ELFFile< ELFT > & getELFFile() const
Definition: ELFObjectFile.h:436
llvm::ELF::EV_CURRENT
@ EV_CURRENT
Definition: ELF.h:128
llvm::ELF::ET_DYN
@ ET_DYN
Definition: ELF.h:119
llvm::ifs::IFSStub
Definition: IFSStub.h:90
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:920
llvm::object::object_error::parse_failed
@ parse_failed
Align
uint64_t Align
Definition: ELFObjHandler.cpp:83
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:453
llvm::ELF::ELFDATA2MSB
@ ELFDATA2MSB
Definition: ELF.h:336
llvm::ELF::SHN_UNDEF
@ SHN_UNDEF
Definition: ELF.h:895
llvm::ifs::IFSTarget::BitWidth
Optional< IFSBitWidthType > BitWidth
Definition: IFSStub.h:71
llvm::ELF::STB_WEAK
@ STB_WEAK
Definition: ELF.h:1140
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::ELFCLASS64
@ ELFCLASS64
Definition: ELF.h:329
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::ifs::DynamicEntries::NeededLibNames
std::vector< uint64_t > NeededLibNames
Definition: ELFObjHandler.cpp:37
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
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:42
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::EI_CLASS
@ EI_CLASS
Definition: ELF.h:53
llvm::object::ELFFile::toMappedAddr
Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const
Definition: ELF.cpp:565
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ELF::STV_DEFAULT
@ STV_DEFAULT
Definition: ELF.h:1168
llvm::object::ELFFile::dynamicEntries
Expected< Elf_Dyn_Range > dynamicEntries() const
Definition: ELF.cpp:514
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(<
llvm::ELF::EI_MAG1
@ EI_MAG1
Definition: ELF.h:50
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:653
NoBits
bool NoBits
Definition: ELFObjHandler.cpp:85
llvm::ifs::DynamicEntries::StrTabAddr
uint64_t StrTabAddr
Definition: ELFObjHandler.cpp:34
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:53
llvm::ELF::STV_PROTECTED
@ STV_PROTECTED
Definition: ELF.h:1171
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:988
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::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:136
llvm::Expected::get
reference get()
Returns a reference to the stored T value.
Definition: Error.h:569
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::ELF::EI_MAG0
@ EI_MAG0
Definition: ELF.h:49
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:158
Size
uint64_t Size
Definition: ELFObjHandler.cpp:82
ELFObjectFile.h
llvm::object::ELFFile::getHeader
const Elf_Ehdr & getHeader() const
Definition: ELF.h:192
llvm::ifs::IFSSymbol::Weak
bool Weak
Definition: IFSStub.h:60
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1231
uint16_t
llvm::ifs::IFSStub::Target
IFSTarget Target
Definition: IFSStub.h:94
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::ELF::EI_OSABI
@ EI_OSABI
Definition: ELF.h:56
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition: StringTableBuilder.h:23
llvm::ELF::EI_VERSION
@ EI_VERSION
Definition: ELF.h:55
llvm::ifs::IFSStub::Symbols
std::vector< IFSSymbol > Symbols
Definition: IFSStub.h:96
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:598
llvm::ELF::ElfMagic
static const char ElfMagic[]
Definition: ELF.h:45
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:589
Binary.h
llvm::ELF::EI_MAG3
@ EI_MAG3
Definition: ELF.h:52
Machine
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:366
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:480
llvm::ifs::DynamicEntries::SONameOffset
Optional< uint64_t > SONameOffset
Definition: ELFObjHandler.cpp:36
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
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:46
llvm::ifs::readELFFile
Expected< std::unique_ptr< IFSStub > > readELFFile(MemoryBufferRef Buf)
Attempt to read a binary ELF file from a MemoryBuffer.
Definition: ELFObjHandler.cpp:632
Name
std::string Name
Definition: ELFObjHandler.cpp:78
llvm::ifs::IFSTarget::Endianness
Optional< IFSEndiannessType > Endianness
Definition: IFSStub.h:70
llvm::object::ELFObjectFile
Definition: ELFObjectFile.h:228
llvm::raw_string_ostream::str
std::string & str()
Flushes the stream contents to the target string and returns the string's reference.
Definition: raw_ostream.h:641
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:380
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::object::ELFFile
Definition: ELF.h:98
llvm::ELF::EI_DATA
@ EI_DATA
Definition: ELF.h:54
llvm::ELF::ELFOSABI_NONE
@ ELFOSABI_NONE
Definition: ELF.h:341
llvm::object::ELFFile::program_headers
Expected< Elf_Phdr_Range > program_headers() const
Iterate over program header table.
Definition: ELF.h:284
llvm::ELF::EI_MAG2
@ EI_MAG2
Definition: ELF.h:51
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:915
Shdr
Elf_Shdr Shdr
Definition: ELFObjHandler.cpp:79