LLVM  10.0.0svn
ELFEmitter.cpp
Go to the documentation of this file.
1 //===- yaml2elf - Convert YAML to a ELF object file -----------------------===//
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 ///
9 /// \file
10 /// The ELF component of yaml2obj.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/StringSet.h"
16 #include "llvm/BinaryFormat/ELF.h"
23 #include "llvm/Support/WithColor.h"
26 
27 using namespace llvm;
28 
29 // This class is used to build up a contiguous binary blob while keeping
30 // track of an offset in the output (which notionally begins at
31 // `InitialOffset`).
32 namespace {
33 class ContiguousBlobAccumulator {
34  const uint64_t InitialOffset;
37 
38  /// \returns The new offset.
39  uint64_t padToAlignment(unsigned Align) {
40  if (Align == 0)
41  Align = 1;
42  uint64_t CurrentOffset = InitialOffset + OS.tell();
43  uint64_t AlignedOffset = alignTo(CurrentOffset, Align);
44  OS.write_zeros(AlignedOffset - CurrentOffset);
45  return AlignedOffset; // == CurrentOffset;
46  }
47 
48 public:
49  ContiguousBlobAccumulator(uint64_t InitialOffset_)
50  : InitialOffset(InitialOffset_), Buf(), OS(Buf) {}
51  template <class Integer>
52  raw_ostream &getOSAndAlignedOffset(Integer &Offset, unsigned Align) {
53  Offset = padToAlignment(Align);
54  return OS;
55  }
56  void writeBlobToStream(raw_ostream &Out) { Out << OS.str(); }
57 };
58 
59 // Used to keep track of section and symbol names, so that in the YAML file
60 // sections and symbols can be referenced by name instead of by index.
61 class NameToIdxMap {
63 
64 public:
65  /// \Returns false if name is already present in the map.
66  bool addName(StringRef Name, unsigned Ndx) {
67  return Map.insert({Name, Ndx}).second;
68  }
69  /// \Returns false if name is not present in the map.
70  bool lookup(StringRef Name, unsigned &Idx) const {
71  auto I = Map.find(Name);
72  if (I == Map.end())
73  return false;
74  Idx = I->getValue();
75  return true;
76  }
77  /// Asserts if name is not present in the map.
78  unsigned get(StringRef Name) const {
79  unsigned Idx;
80  if (lookup(Name, Idx))
81  return Idx;
82  assert(false && "Expected section not found in index");
83  return 0;
84  }
85  unsigned size() const { return Map.size(); }
86 };
87 
88 /// "Single point of truth" for the ELF file construction.
89 /// TODO: This class still has a ways to go before it is truly a "single
90 /// point of truth".
91 template <class ELFT> class ELFState {
92  typedef typename ELFT::Ehdr Elf_Ehdr;
93  typedef typename ELFT::Phdr Elf_Phdr;
94  typedef typename ELFT::Shdr Elf_Shdr;
95  typedef typename ELFT::Sym Elf_Sym;
96  typedef typename ELFT::Rel Elf_Rel;
97  typedef typename ELFT::Rela Elf_Rela;
98  typedef typename ELFT::Relr Elf_Relr;
99  typedef typename ELFT::Dyn Elf_Dyn;
100 
101  enum class SymtabType { Static, Dynamic };
102 
103  /// The future ".strtab" section.
105 
106  /// The future ".shstrtab" section.
108 
109  /// The future ".dynstr" section.
111 
112  NameToIdxMap SN2I;
113  NameToIdxMap SymN2I;
114  NameToIdxMap DynSymN2I;
115  ELFYAML::Object &Doc;
116 
117  bool HasError = false;
118  yaml::ErrorHandler ErrHandler;
119  void reportError(const Twine &Msg);
120 
121  std::vector<Elf_Sym> toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
122  const StringTableBuilder &Strtab);
123  unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
124  unsigned toSymbolIndex(StringRef S, StringRef LocSec, bool IsDynamic);
125 
126  void buildSectionIndex();
127  void buildSymbolIndexes();
128  void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
129  bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
130  StringRef SecName, ELFYAML::Section *YAMLSec);
131  void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
132  ContiguousBlobAccumulator &CBA);
133  void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
134  ContiguousBlobAccumulator &CBA,
135  ELFYAML::Section *YAMLSec);
136  void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
137  StringTableBuilder &STB,
138  ContiguousBlobAccumulator &CBA,
139  ELFYAML::Section *YAMLSec);
140  void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
141  std::vector<Elf_Shdr> &SHeaders);
142  void finalizeStrings();
143  void writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS);
144  void writeSectionContent(Elf_Shdr &SHeader,
146  ContiguousBlobAccumulator &CBA);
147  void writeSectionContent(Elf_Shdr &SHeader,
149  ContiguousBlobAccumulator &CBA);
150  void writeSectionContent(Elf_Shdr &SHeader, const ELFYAML::Group &Group,
151  ContiguousBlobAccumulator &CBA);
152  void writeSectionContent(Elf_Shdr &SHeader,
153  const ELFYAML::SymtabShndxSection &Shndx,
154  ContiguousBlobAccumulator &CBA);
155  void writeSectionContent(Elf_Shdr &SHeader,
157  ContiguousBlobAccumulator &CBA);
158  void writeSectionContent(Elf_Shdr &SHeader,
160  ContiguousBlobAccumulator &CBA);
161  void writeSectionContent(Elf_Shdr &SHeader,
163  ContiguousBlobAccumulator &CBA);
164  void writeSectionContent(Elf_Shdr &SHeader,
166  ContiguousBlobAccumulator &CBA);
167  void writeSectionContent(Elf_Shdr &SHeader,
169  ContiguousBlobAccumulator &CBA);
170  ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
171 
172 public:
173  static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
174  yaml::ErrorHandler EH);
175 };
176 } // end anonymous namespace
177 
178 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
179  return A.size() * sizeof(T);
180 }
181 
182 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
183  OS.write((const char *)A.data(), arrayDataSize(A));
184 }
185 
186 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
187 
188 template <class ELFT>
189 ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
190  : Doc(D), ErrHandler(EH) {
191  StringSet<> DocSections;
192  for (std::unique_ptr<ELFYAML::Section> &D : Doc.Sections)
193  if (!D->Name.empty())
194  DocSections.insert(D->Name);
195 
196  // Insert SHT_NULL section implicitly when it is not defined in YAML.
197  if (Doc.Sections.empty() || Doc.Sections.front()->Type != ELF::SHT_NULL)
198  Doc.Sections.insert(
199  Doc.Sections.begin(),
200  std::make_unique<ELFYAML::Section>(
201  ELFYAML::Section::SectionKind::RawContent, /*IsImplicit=*/true));
202 
203  std::vector<StringRef> ImplicitSections = {".symtab", ".strtab", ".shstrtab"};
204  if (!Doc.DynamicSymbols.empty())
205  ImplicitSections.insert(ImplicitSections.end(), {".dynsym", ".dynstr"});
206 
207  // Insert placeholders for implicit sections that are not
208  // defined explicitly in YAML.
209  for (StringRef SecName : ImplicitSections) {
210  if (DocSections.count(SecName))
211  continue;
212 
213  std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
214  ELFYAML::Section::SectionKind::RawContent, true /*IsImplicit*/);
215  Sec->Name = SecName;
216  Doc.Sections.push_back(std::move(Sec));
217  }
218 }
219 
220 template <class ELFT>
221 void ELFState<ELFT>::writeELFHeader(ContiguousBlobAccumulator &CBA, raw_ostream &OS) {
222  using namespace llvm::ELF;
223 
224  Elf_Ehdr Header;
225  zero(Header);
226  Header.e_ident[EI_MAG0] = 0x7f;
227  Header.e_ident[EI_MAG1] = 'E';
228  Header.e_ident[EI_MAG2] = 'L';
229  Header.e_ident[EI_MAG3] = 'F';
230  Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
231  Header.e_ident[EI_DATA] = Doc.Header.Data;
232  Header.e_ident[EI_VERSION] = EV_CURRENT;
233  Header.e_ident[EI_OSABI] = Doc.Header.OSABI;
234  Header.e_ident[EI_ABIVERSION] = Doc.Header.ABIVersion;
235  Header.e_type = Doc.Header.Type;
236  Header.e_machine = Doc.Header.Machine;
237  Header.e_version = EV_CURRENT;
238  Header.e_entry = Doc.Header.Entry;
239  Header.e_phoff = Doc.ProgramHeaders.size() ? sizeof(Header) : 0;
240  Header.e_flags = Doc.Header.Flags;
241  Header.e_ehsize = sizeof(Elf_Ehdr);
242  Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
243  Header.e_phnum = Doc.ProgramHeaders.size();
244 
245  Header.e_shentsize =
246  Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
247  // Immediately following the ELF header and program headers.
248  // Align the start of the section header and write the ELF header.
249  uint64_t SHOff;
250  CBA.getOSAndAlignedOffset(SHOff, sizeof(typename ELFT::uint));
251  Header.e_shoff =
252  Doc.Header.SHOff ? typename ELFT::uint(*Doc.Header.SHOff) : SHOff;
253  Header.e_shnum =
254  Doc.Header.SHNum ? (uint16_t)*Doc.Header.SHNum : Doc.Sections.size();
255  Header.e_shstrndx = Doc.Header.SHStrNdx ? (uint16_t)*Doc.Header.SHStrNdx
256  : SN2I.get(".shstrtab");
257 
258  OS.write((const char *)&Header, sizeof(Header));
259 }
260 
261 template <class ELFT>
262 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
263  for (const auto &YamlPhdr : Doc.ProgramHeaders) {
264  Elf_Phdr Phdr;
265  Phdr.p_type = YamlPhdr.Type;
266  Phdr.p_flags = YamlPhdr.Flags;
267  Phdr.p_vaddr = YamlPhdr.VAddr;
268  Phdr.p_paddr = YamlPhdr.PAddr;
269  PHeaders.push_back(Phdr);
270  }
271 }
272 
273 template <class ELFT>
274 unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
275  StringRef LocSym) {
276  unsigned Index;
277  if (SN2I.lookup(S, Index) || to_integer(S, Index))
278  return Index;
279 
280  assert(LocSec.empty() || LocSym.empty());
281  if (!LocSym.empty())
282  reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
283  LocSym + "'");
284  else
285  reportError("unknown section referenced: '" + S + "' by YAML section '" +
286  LocSec + "'");
287  return 0;
288 }
289 
290 template <class ELFT>
291 unsigned ELFState<ELFT>::toSymbolIndex(StringRef S, StringRef LocSec,
292  bool IsDynamic) {
293  const NameToIdxMap &SymMap = IsDynamic ? DynSymN2I : SymN2I;
294  unsigned Index;
295  // Here we try to look up S in the symbol table. If it is not there,
296  // treat its value as a symbol index.
297  if (!SymMap.lookup(S, Index) && !to_integer(S, Index)) {
298  reportError("unknown symbol referenced: '" + S + "' by YAML section '" +
299  LocSec + "'");
300  return 0;
301  }
302  return Index;
303 }
304 
305 template <class ELFT>
306 bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
307  Elf_Shdr &Header, StringRef SecName,
308  ELFYAML::Section *YAMLSec) {
309  // Check if the header was already initialized.
310  if (Header.sh_offset)
311  return false;
312 
313  if (SecName == ".symtab")
314  initSymtabSectionHeader(Header, SymtabType::Static, CBA, YAMLSec);
315  else if (SecName == ".strtab")
316  initStrtabSectionHeader(Header, SecName, DotStrtab, CBA, YAMLSec);
317  else if (SecName == ".shstrtab")
318  initStrtabSectionHeader(Header, SecName, DotShStrtab, CBA, YAMLSec);
319  else if (SecName == ".dynsym")
320  initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, YAMLSec);
321  else if (SecName == ".dynstr")
322  initStrtabSectionHeader(Header, SecName, DotDynstr, CBA, YAMLSec);
323  else
324  return false;
325 
326  // Override the fields if requested.
327  if (YAMLSec) {
328  if (YAMLSec->ShName)
329  Header.sh_name = *YAMLSec->ShName;
330  if (YAMLSec->ShOffset)
331  Header.sh_offset = *YAMLSec->ShOffset;
332  if (YAMLSec->ShSize)
333  Header.sh_size = *YAMLSec->ShSize;
334  }
335 
336  return true;
337 }
338 
340  size_t SuffixPos = S.rfind(" [");
341  if (SuffixPos == StringRef::npos)
342  return S;
343  return S.substr(0, SuffixPos);
344 }
345 
346 template <class ELFT>
347 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
348  ContiguousBlobAccumulator &CBA) {
349  // Ensure SHN_UNDEF entry is present. An all-zero section header is a
350  // valid SHN_UNDEF entry since SHT_NULL == 0.
351  SHeaders.resize(Doc.Sections.size());
352 
353  for (size_t I = 0; I < Doc.Sections.size(); ++I) {
354  ELFYAML::Section *Sec = Doc.Sections[I].get();
355  if (I == 0 && Sec->IsImplicit)
356  continue;
357 
358  // We have a few sections like string or symbol tables that are usually
359  // added implicitly to the end. However, if they are explicitly specified
360  // in the YAML, we need to write them here. This ensures the file offset
361  // remains correct.
362  Elf_Shdr &SHeader = SHeaders[I];
363  if (initImplicitHeader(CBA, SHeader, Sec->Name,
364  Sec->IsImplicit ? nullptr : Sec))
365  continue;
366 
367  assert(Sec && "It can't be null unless it is an implicit section. But all "
368  "implicit sections should already have been handled above.");
369 
370  SHeader.sh_name = DotShStrtab.getOffset(dropUniqueSuffix(Sec->Name));
371  SHeader.sh_type = Sec->Type;
372  if (Sec->Flags)
373  SHeader.sh_flags = *Sec->Flags;
374  SHeader.sh_addr = Sec->Address;
375  SHeader.sh_addralign = Sec->AddressAlign;
376 
377  if (!Sec->Link.empty())
378  SHeader.sh_link = toSectionIndex(Sec->Link, Sec->Name);
379 
380  if (I == 0) {
381  if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
382  // We do not write any content for special SHN_UNDEF section.
383  if (RawSec->Size)
384  SHeader.sh_size = *RawSec->Size;
385  if (RawSec->Info)
386  SHeader.sh_info = *RawSec->Info;
387  }
388  if (Sec->EntSize)
389  SHeader.sh_entsize = *Sec->EntSize;
390  } else if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
391  writeSectionContent(SHeader, *S, CBA);
392  } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
393  writeSectionContent(SHeader, *S, CBA);
394  } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
395  writeSectionContent(SHeader, *S, CBA);
396  } else if (auto S = dyn_cast<ELFYAML::Group>(Sec)) {
397  writeSectionContent(SHeader, *S, CBA);
398  } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec)) {
399  writeSectionContent(SHeader, *S, CBA);
400  } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec)) {
401  SHeader.sh_entsize = 0;
402  SHeader.sh_size = S->Size;
403  // SHT_NOBITS section does not have content
404  // so just to setup the section offset.
405  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
406  } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec)) {
407  writeSectionContent(SHeader, *S, CBA);
408  } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
409  writeSectionContent(SHeader, *S, CBA);
410  } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
411  writeSectionContent(SHeader, *S, CBA);
412  } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
413  writeSectionContent(SHeader, *S, CBA);
414  } else {
415  llvm_unreachable("Unknown section type");
416  }
417 
418  // Override the fields if requested.
419  if (Sec) {
420  if (Sec->ShName)
421  SHeader.sh_name = *Sec->ShName;
422  if (Sec->ShOffset)
423  SHeader.sh_offset = *Sec->ShOffset;
424  if (Sec->ShSize)
425  SHeader.sh_size = *Sec->ShSize;
426  }
427  }
428 }
429 
431  for (size_t I = 0; I < Symbols.size(); ++I)
432  if (Symbols[I].Binding.value != ELF::STB_LOCAL)
433  return I;
434  return Symbols.size();
435 }
436 
437 static uint64_t writeRawSectionData(raw_ostream &OS,
438  const ELFYAML::RawContentSection &RawSec) {
439  size_t ContentSize = 0;
440  if (RawSec.Content) {
441  RawSec.Content->writeAsBinary(OS);
442  ContentSize = RawSec.Content->binary_size();
443  }
444 
445  if (!RawSec.Size)
446  return ContentSize;
447 
448  OS.write_zeros(*RawSec.Size - ContentSize);
449  return *RawSec.Size;
450 }
451 
452 template <class ELFT>
453 std::vector<typename ELFT::Sym>
454 ELFState<ELFT>::toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
455  const StringTableBuilder &Strtab) {
456  std::vector<Elf_Sym> Ret;
457  Ret.resize(Symbols.size() + 1);
458 
459  size_t I = 0;
460  for (const auto &Sym : Symbols) {
461  Elf_Sym &Symbol = Ret[++I];
462 
463  // If NameIndex, which contains the name offset, is explicitly specified, we
464  // use it. This is useful for preparing broken objects. Otherwise, we add
465  // the specified Name to the string table builder to get its offset.
466  if (Sym.NameIndex)
467  Symbol.st_name = *Sym.NameIndex;
468  else if (!Sym.Name.empty())
469  Symbol.st_name = Strtab.getOffset(dropUniqueSuffix(Sym.Name));
470 
471  Symbol.setBindingAndType(Sym.Binding, Sym.Type);
472  if (!Sym.Section.empty())
473  Symbol.st_shndx = toSectionIndex(Sym.Section, "", Sym.Name);
474  else if (Sym.Index)
475  Symbol.st_shndx = *Sym.Index;
476 
477  Symbol.st_value = Sym.Value;
478  Symbol.st_other = Sym.Other ? *Sym.Other : 0;
479  Symbol.st_size = Sym.Size;
480  }
481 
482  return Ret;
483 }
484 
485 template <class ELFT>
486 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
487  SymtabType STType,
488  ContiguousBlobAccumulator &CBA,
489  ELFYAML::Section *YAMLSec) {
490 
491  bool IsStatic = STType == SymtabType::Static;
492  const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
493 
495  dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
496  if (RawSec && !Symbols.empty() && (RawSec->Content || RawSec->Size)) {
497  if (RawSec->Content)
498  reportError("cannot specify both `Content` and " +
499  (IsStatic ? Twine("`Symbols`") : Twine("`DynamicSymbols`")) +
500  " for symbol table section '" + RawSec->Name + "'");
501  if (RawSec->Size)
502  reportError("cannot specify both `Size` and " +
503  (IsStatic ? Twine("`Symbols`") : Twine("`DynamicSymbols`")) +
504  " for symbol table section '" + RawSec->Name + "'");
505  return;
506  }
507 
508  zero(SHeader);
509  SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
510 
511  if (YAMLSec)
512  SHeader.sh_type = YAMLSec->Type;
513  else
514  SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
515 
516  if (RawSec && !RawSec->Link.empty()) {
517  // If the Link field is explicitly defined in the document,
518  // we should use it.
519  SHeader.sh_link = toSectionIndex(RawSec->Link, RawSec->Name);
520  } else {
521  // When we describe the .dynsym section in the document explicitly, it is
522  // allowed to omit the "DynamicSymbols" tag. In this case .dynstr is not
523  // added implicitly and we should be able to leave the Link zeroed if
524  // .dynstr is not defined.
525  unsigned Link = 0;
526  if (IsStatic)
527  Link = SN2I.get(".strtab");
528  else
529  SN2I.lookup(".dynstr", Link);
530  SHeader.sh_link = Link;
531  }
532 
533  if (YAMLSec && YAMLSec->Flags)
534  SHeader.sh_flags = *YAMLSec->Flags;
535  else if (!IsStatic)
536  SHeader.sh_flags = ELF::SHF_ALLOC;
537 
538  // If the symbol table section is explicitly described in the YAML
539  // then we should set the fields requested.
540  SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
541  : findFirstNonGlobal(Symbols) + 1;
542  SHeader.sh_entsize = (YAMLSec && YAMLSec->EntSize)
543  ? (uint64_t)(*YAMLSec->EntSize)
544  : sizeof(Elf_Sym);
545  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
546  SHeader.sh_addr = YAMLSec ? (uint64_t)YAMLSec->Address : 0;
547 
548  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
549  if (RawSec && (RawSec->Content || RawSec->Size)) {
550  assert(Symbols.empty());
551  SHeader.sh_size = writeRawSectionData(OS, *RawSec);
552  return;
553  }
554 
555  std::vector<Elf_Sym> Syms =
556  toELFSymbols(Symbols, IsStatic ? DotStrtab : DotDynstr);
557  writeArrayData(OS, makeArrayRef(Syms));
558  SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
559 }
560 
561 template <class ELFT>
562 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
563  StringTableBuilder &STB,
564  ContiguousBlobAccumulator &CBA,
565  ELFYAML::Section *YAMLSec) {
566  zero(SHeader);
567  SHeader.sh_name = DotShStrtab.getOffset(Name);
568  SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
569  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
570 
572  dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
573 
574  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
575  if (RawSec && (RawSec->Content || RawSec->Size)) {
576  SHeader.sh_size = writeRawSectionData(OS, *RawSec);
577  } else {
578  STB.write(OS);
579  SHeader.sh_size = STB.getSize();
580  }
581 
582  if (YAMLSec && YAMLSec->EntSize)
583  SHeader.sh_entsize = *YAMLSec->EntSize;
584 
585  if (RawSec && RawSec->Info)
586  SHeader.sh_info = *RawSec->Info;
587 
588  if (YAMLSec && YAMLSec->Flags)
589  SHeader.sh_flags = *YAMLSec->Flags;
590  else if (Name == ".dynstr")
591  SHeader.sh_flags = ELF::SHF_ALLOC;
592 
593  // If the section is explicitly described in the YAML
594  // then we want to use its section address.
595  if (YAMLSec)
596  SHeader.sh_addr = YAMLSec->Address;
597 }
598 
599 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
600  ErrHandler(Msg);
601  HasError = true;
602 }
603 
604 template <class ELFT>
605 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
606  std::vector<Elf_Shdr> &SHeaders) {
607  uint32_t PhdrIdx = 0;
608  for (auto &YamlPhdr : Doc.ProgramHeaders) {
609  Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
610 
611  std::vector<Elf_Shdr *> Sections;
612  for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
613  unsigned Index;
614  if (!SN2I.lookup(SecName.Section, Index)) {
615  reportError("unknown section referenced: '" + SecName.Section +
616  "' by program header");
617  continue;
618  }
619  Sections.push_back(&SHeaders[Index]);
620  }
621 
622  if (YamlPhdr.Offset) {
623  PHeader.p_offset = *YamlPhdr.Offset;
624  } else {
625  if (YamlPhdr.Sections.size())
626  PHeader.p_offset = UINT32_MAX;
627  else
628  PHeader.p_offset = 0;
629 
630  // Find the minimum offset for the program header.
631  for (Elf_Shdr *SHeader : Sections)
632  PHeader.p_offset = std::min(PHeader.p_offset, SHeader->sh_offset);
633  }
634 
635  // Find the maximum offset of the end of a section in order to set p_filesz
636  // and p_memsz. When setting p_filesz, trailing SHT_NOBITS sections are not
637  // counted.
638  uint64_t FileOffset = PHeader.p_offset, MemOffset = PHeader.p_offset;
639  for (Elf_Shdr *SHeader : Sections) {
640  uint64_t End = SHeader->sh_offset + SHeader->sh_size;
641  MemOffset = std::max(MemOffset, End);
642 
643  if (SHeader->sh_type != llvm::ELF::SHT_NOBITS)
644  FileOffset = std::max(FileOffset, End);
645  }
646 
647  // Set the file size and the memory size if not set explicitly.
648  PHeader.p_filesz = YamlPhdr.FileSize ? uint64_t(*YamlPhdr.FileSize)
649  : FileOffset - PHeader.p_offset;
650  PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize)
651  : MemOffset - PHeader.p_offset;
652 
653  if (YamlPhdr.Align) {
654  PHeader.p_align = *YamlPhdr.Align;
655  } else {
656  // Set the alignment of the segment to be the maximum alignment of the
657  // sections so that by default the segment has a valid and sensible
658  // alignment.
659  PHeader.p_align = 1;
660  for (Elf_Shdr *SHeader : Sections)
661  PHeader.p_align = std::max(PHeader.p_align, SHeader->sh_addralign);
662  }
663  }
664 }
665 
666 template <class ELFT>
667 void ELFState<ELFT>::writeSectionContent(
668  Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
669  ContiguousBlobAccumulator &CBA) {
670  raw_ostream &OS =
671  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
672  SHeader.sh_size = writeRawSectionData(OS, Section);
673 
674  if (Section.EntSize)
675  SHeader.sh_entsize = *Section.EntSize;
676  else if (Section.Type == llvm::ELF::SHT_RELR)
677  SHeader.sh_entsize = sizeof(Elf_Relr);
678  else
679  SHeader.sh_entsize = 0;
680 
681  if (Section.Info)
682  SHeader.sh_info = *Section.Info;
683 }
684 
685 static bool isMips64EL(const ELFYAML::Object &Doc) {
686  return Doc.Header.Machine == ELFYAML::ELF_EM(llvm::ELF::EM_MIPS) &&
687  Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
688  Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
689 }
690 
691 template <class ELFT>
692 void ELFState<ELFT>::writeSectionContent(
693  Elf_Shdr &SHeader, const ELFYAML::RelocationSection &Section,
694  ContiguousBlobAccumulator &CBA) {
695  assert((Section.Type == llvm::ELF::SHT_REL ||
696  Section.Type == llvm::ELF::SHT_RELA) &&
697  "Section type is not SHT_REL nor SHT_RELA");
698 
699  bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
700  SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
701  SHeader.sh_size = SHeader.sh_entsize * Section.Relocations.size();
702 
703  // For relocation section set link to .symtab by default.
704  if (Section.Link.empty())
705  SHeader.sh_link = SN2I.get(".symtab");
706 
707  if (!Section.RelocatableSec.empty())
708  SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
709 
710  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
711  for (const auto &Rel : Section.Relocations) {
712  unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,
713  Section.Link == ".dynsym")
714  : 0;
715  if (IsRela) {
716  Elf_Rela REntry;
717  zero(REntry);
718  REntry.r_offset = Rel.Offset;
719  REntry.r_addend = Rel.Addend;
720  REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
721  OS.write((const char *)&REntry, sizeof(REntry));
722  } else {
723  Elf_Rel REntry;
724  zero(REntry);
725  REntry.r_offset = Rel.Offset;
726  REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
727  OS.write((const char *)&REntry, sizeof(REntry));
728  }
729  }
730 }
731 
732 template <class ELFT>
733 void ELFState<ELFT>::writeSectionContent(
734  Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
735  ContiguousBlobAccumulator &CBA) {
736  raw_ostream &OS =
737  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
738 
739  for (uint32_t E : Shndx.Entries)
740  support::endian::write<uint32_t>(OS, E, ELFT::TargetEndianness);
741 
742  SHeader.sh_entsize = Shndx.EntSize ? (uint64_t)*Shndx.EntSize : 4;
743  SHeader.sh_size = Shndx.Entries.size() * SHeader.sh_entsize;
744 }
745 
746 template <class ELFT>
747 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
748  const ELFYAML::Group &Section,
749  ContiguousBlobAccumulator &CBA) {
750  assert(Section.Type == llvm::ELF::SHT_GROUP &&
751  "Section type is not SHT_GROUP");
752 
753  SHeader.sh_entsize = 4;
754  SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
755  SHeader.sh_info =
756  toSymbolIndex(Section.Signature, Section.Name, /*IsDynamic=*/false);
757 
758  raw_ostream &OS =
759  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
760 
761  for (const ELFYAML::SectionOrType &Member : Section.Members) {
762  unsigned int SectionIndex = 0;
763  if (Member.sectionNameOrType == "GRP_COMDAT")
764  SectionIndex = llvm::ELF::GRP_COMDAT;
765  else
766  SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
767  support::endian::write<uint32_t>(OS, SectionIndex, ELFT::TargetEndianness);
768  }
769 }
770 
771 template <class ELFT>
772 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
773  const ELFYAML::SymverSection &Section,
774  ContiguousBlobAccumulator &CBA) {
775  raw_ostream &OS =
776  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
777  for (uint16_t Version : Section.Entries)
778  support::endian::write<uint16_t>(OS, Version, ELFT::TargetEndianness);
779 
780  SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
781  SHeader.sh_size = Section.Entries.size() * SHeader.sh_entsize;
782 }
783 
784 template <class ELFT>
785 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
786  const ELFYAML::VerdefSection &Section,
787  ContiguousBlobAccumulator &CBA) {
788  typedef typename ELFT::Verdef Elf_Verdef;
789  typedef typename ELFT::Verdaux Elf_Verdaux;
790  raw_ostream &OS =
791  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
792 
793  uint64_t AuxCnt = 0;
794  for (size_t I = 0; I < Section.Entries.size(); ++I) {
795  const ELFYAML::VerdefEntry &E = Section.Entries[I];
796 
797  Elf_Verdef VerDef;
798  VerDef.vd_version = E.Version;
799  VerDef.vd_flags = E.Flags;
800  VerDef.vd_ndx = E.VersionNdx;
801  VerDef.vd_hash = E.Hash;
802  VerDef.vd_aux = sizeof(Elf_Verdef);
803  VerDef.vd_cnt = E.VerNames.size();
804  if (I == Section.Entries.size() - 1)
805  VerDef.vd_next = 0;
806  else
807  VerDef.vd_next =
808  sizeof(Elf_Verdef) + E.VerNames.size() * sizeof(Elf_Verdaux);
809  OS.write((const char *)&VerDef, sizeof(Elf_Verdef));
810 
811  for (size_t J = 0; J < E.VerNames.size(); ++J, ++AuxCnt) {
812  Elf_Verdaux VernAux;
813  VernAux.vda_name = DotDynstr.getOffset(E.VerNames[J]);
814  if (J == E.VerNames.size() - 1)
815  VernAux.vda_next = 0;
816  else
817  VernAux.vda_next = sizeof(Elf_Verdaux);
818  OS.write((const char *)&VernAux, sizeof(Elf_Verdaux));
819  }
820  }
821 
822  SHeader.sh_size = Section.Entries.size() * sizeof(Elf_Verdef) +
823  AuxCnt * sizeof(Elf_Verdaux);
824  SHeader.sh_info = Section.Info;
825 }
826 
827 template <class ELFT>
828 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
829  const ELFYAML::VerneedSection &Section,
830  ContiguousBlobAccumulator &CBA) {
831  typedef typename ELFT::Verneed Elf_Verneed;
832  typedef typename ELFT::Vernaux Elf_Vernaux;
833 
834  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
835 
836  uint64_t AuxCnt = 0;
837  for (size_t I = 0; I < Section.VerneedV.size(); ++I) {
838  const ELFYAML::VerneedEntry &VE = Section.VerneedV[I];
839 
840  Elf_Verneed VerNeed;
841  VerNeed.vn_version = VE.Version;
842  VerNeed.vn_file = DotDynstr.getOffset(VE.File);
843  if (I == Section.VerneedV.size() - 1)
844  VerNeed.vn_next = 0;
845  else
846  VerNeed.vn_next =
847  sizeof(Elf_Verneed) + VE.AuxV.size() * sizeof(Elf_Vernaux);
848  VerNeed.vn_cnt = VE.AuxV.size();
849  VerNeed.vn_aux = sizeof(Elf_Verneed);
850  OS.write((const char *)&VerNeed, sizeof(Elf_Verneed));
851 
852  for (size_t J = 0; J < VE.AuxV.size(); ++J, ++AuxCnt) {
853  const ELFYAML::VernauxEntry &VAuxE = VE.AuxV[J];
854 
855  Elf_Vernaux VernAux;
856  VernAux.vna_hash = VAuxE.Hash;
857  VernAux.vna_flags = VAuxE.Flags;
858  VernAux.vna_other = VAuxE.Other;
859  VernAux.vna_name = DotDynstr.getOffset(VAuxE.Name);
860  if (J == VE.AuxV.size() - 1)
861  VernAux.vna_next = 0;
862  else
863  VernAux.vna_next = sizeof(Elf_Vernaux);
864  OS.write((const char *)&VernAux, sizeof(Elf_Vernaux));
865  }
866  }
867 
868  SHeader.sh_size = Section.VerneedV.size() * sizeof(Elf_Verneed) +
869  AuxCnt * sizeof(Elf_Vernaux);
870  SHeader.sh_info = Section.Info;
871 }
872 
873 template <class ELFT>
874 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
875  const ELFYAML::MipsABIFlags &Section,
876  ContiguousBlobAccumulator &CBA) {
878  "Section type is not SHT_MIPS_ABIFLAGS");
879 
881  zero(Flags);
882  SHeader.sh_entsize = sizeof(Flags);
883  SHeader.sh_size = SHeader.sh_entsize;
884 
885  auto &OS = CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
886  Flags.version = Section.Version;
887  Flags.isa_level = Section.ISALevel;
888  Flags.isa_rev = Section.ISARevision;
889  Flags.gpr_size = Section.GPRSize;
890  Flags.cpr1_size = Section.CPR1Size;
891  Flags.cpr2_size = Section.CPR2Size;
892  Flags.fp_abi = Section.FpABI;
893  Flags.isa_ext = Section.ISAExtension;
894  Flags.ases = Section.ASEs;
895  Flags.flags1 = Section.Flags1;
896  Flags.flags2 = Section.Flags2;
897  OS.write((const char *)&Flags, sizeof(Flags));
898 }
899 
900 template <class ELFT>
901 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
902  const ELFYAML::DynamicSection &Section,
903  ContiguousBlobAccumulator &CBA) {
904  typedef typename ELFT::uint uintX_t;
905 
906  assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
907  "Section type is not SHT_DYNAMIC");
908 
909  if (!Section.Entries.empty() && Section.Content)
910  reportError("cannot specify both raw content and explicit entries "
911  "for dynamic section '" +
912  Section.Name + "'");
913 
914  if (Section.Content)
915  SHeader.sh_size = Section.Content->binary_size();
916  else
917  SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries.size();
918  if (Section.EntSize)
919  SHeader.sh_entsize = *Section.EntSize;
920  else
921  SHeader.sh_entsize = sizeof(Elf_Dyn);
922 
923  raw_ostream &OS =
924  CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
925  for (const ELFYAML::DynamicEntry &DE : Section.Entries) {
926  support::endian::write<uintX_t>(OS, DE.Tag, ELFT::TargetEndianness);
927  support::endian::write<uintX_t>(OS, DE.Val, ELFT::TargetEndianness);
928  }
929  if (Section.Content)
930  Section.Content->writeAsBinary(OS);
931 }
932 
933 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
934  for (unsigned I = 0, E = Doc.Sections.size(); I != E; ++I) {
935  StringRef Name = Doc.Sections[I]->Name;
936  if (Name.empty())
937  continue;
938 
939  DotShStrtab.add(dropUniqueSuffix(Name));
940  if (!SN2I.addName(Name, I))
941  reportError("repeated section name: '" + Name +
942  "' at YAML section number " + Twine(I));
943  }
944 
945  DotShStrtab.finalize();
946 }
947 
948 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {
949  auto Build = [this](ArrayRef<ELFYAML::Symbol> V, NameToIdxMap &Map) {
950  for (size_t I = 0, S = V.size(); I < S; ++I) {
951  const ELFYAML::Symbol &Sym = V[I];
952  if (!Sym.Name.empty() && !Map.addName(Sym.Name, I + 1))
953  reportError("repeated symbol name: '" + Sym.Name + "'");
954  }
955  };
956 
957  Build(Doc.Symbols, SymN2I);
958  Build(Doc.DynamicSymbols, DynSymN2I);
959 }
960 
961 template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
962  // Add the regular symbol names to .strtab section.
963  for (const ELFYAML::Symbol &Sym : Doc.Symbols)
964  DotStrtab.add(dropUniqueSuffix(Sym.Name));
965  DotStrtab.finalize();
966 
967  // Add the dynamic symbol names to .dynstr section.
968  for (const ELFYAML::Symbol &Sym : Doc.DynamicSymbols)
969  DotDynstr.add(dropUniqueSuffix(Sym.Name));
970 
971  // SHT_GNU_verdef and SHT_GNU_verneed sections might also
972  // add strings to .dynstr section.
973  for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
974  if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
975  for (const ELFYAML::VerneedEntry &VE : VerNeed->VerneedV) {
976  DotDynstr.add(VE.File);
977  for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
978  DotDynstr.add(Aux.Name);
979  }
980  } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec.get())) {
981  for (const ELFYAML::VerdefEntry &E : VerDef->Entries)
982  for (StringRef Name : E.VerNames)
983  DotDynstr.add(Name);
984  }
985  }
986 
987  DotDynstr.finalize();
988 }
989 
990 template <class ELFT>
991 bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
992  yaml::ErrorHandler EH) {
993  ELFState<ELFT> State(Doc, EH);
994 
995  // Finalize .strtab and .dynstr sections. We do that early because want to
996  // finalize the string table builders before writing the content of the
997  // sections that might want to use them.
998  State.finalizeStrings();
999 
1000  State.buildSectionIndex();
1001  State.buildSymbolIndexes();
1002 
1003  std::vector<Elf_Phdr> PHeaders;
1004  State.initProgramHeaders(PHeaders);
1005 
1006  // XXX: This offset is tightly coupled with the order that we write
1007  // things to `OS`.
1008  const size_t SectionContentBeginOffset =
1009  sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
1010  ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
1011 
1012  std::vector<Elf_Shdr> SHeaders;
1013  State.initSectionHeaders(SHeaders, CBA);
1014 
1015  // Now we can decide segment offsets
1016  State.setProgramHeaderLayout(PHeaders, SHeaders);
1017 
1018  if (State.HasError)
1019  return false;
1020 
1021  State.writeELFHeader(CBA, OS);
1022  writeArrayData(OS, makeArrayRef(PHeaders));
1023  CBA.writeBlobToStream(OS);
1024  writeArrayData(OS, makeArrayRef(SHeaders));
1025  return true;
1026 }
1027 
1028 namespace llvm {
1029 namespace yaml {
1030 
1032  bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
1033  bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
1034  if (Is64Bit) {
1035  if (IsLE)
1036  return ELFState<object::ELF64LE>::writeELF(Out, Doc, EH);
1037  return ELFState<object::ELF64BE>::writeELF(Out, Doc, EH);
1038  }
1039  if (IsLE)
1040  return ELFState<object::ELF32LE>::writeELF(Out, Doc, EH);
1041  return ELFState<object::ELF32BE>::writeELF(Out, Doc, EH);
1042 }
1043 
1044 } // namespace yaml
1045 } // namespace llvm
This file declares classes for handling the YAML representation of ELF.
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Optional< ELF_SHF > Flags
Definition: ELFYAML.h:136
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool to_integer(StringRef S, N &Num, unsigned Base=0)
Convert the string S to an integer of the specified type using the radix Base.
Definition: StringExtras.h:193
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
LLVM_NODISCARD size_t rfind(char C, size_t From=npos) const
Search for the last character C in the string.
Definition: StringRef.h:359
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert &#39;NumZeros&#39; nulls.
static StringRef dropUniqueSuffix(StringRef S)
Definition: ELFEmitter.cpp:339
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:104
iterator find(StringRef Key)
Definition: StringMap.h:332
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:530
unsigned second
llvm::yaml::Hex16 Version
Definition: ELFYAML.h:295
Optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:179
llvm::yaml::Hex64 Info
Definition: ELFYAML.h:243
llvm::yaml::Hex64 Address
Definition: ELFYAML.h:137
FileHeader Header
Definition: ELFYAML.h:315
llvm::yaml::Hex64 AddressAlign
Definition: ELFYAML.h:139
std::vector< DynamicEntry > Entries
Definition: ELFYAML.h:167
unsigned size() const
Definition: StringMap.h:111
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
static void zero(T &Obj)
Definition: ELFEmitter.cpp:186
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:450
static uint64_t writeRawSectionData(raw_ostream &OS, const ELFYAML::RawContentSection &RawSec)
Definition: ELFEmitter.cpp:437
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:592
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
llvm::yaml::Hex64 Info
Definition: ELFYAML.h:214
void write(raw_ostream &OS) const
Utility for building string tables with deduplicated suffixes.
Optional< llvm::yaml::Hex64 > EntSize
Definition: ELFYAML.h:140
static void writeArrayData(raw_ostream &OS, ArrayRef< T > A)
Definition: ELFEmitter.cpp:182
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
Definition: ELF.h:26
Optional< llvm::yaml::Hex64 > ShSize
Definition: ELFYAML.h:163
std::vector< ProgramHeader > ProgramHeaders
Definition: ELFYAML.h:316
std::vector< VernauxEntry > AuxV
Definition: ELFYAML.h:209
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:358
llvm::yaml::Hex32 Flags2
Definition: ELFYAML.h:305
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::vector< uint32_t > Entries
Definition: ELFYAML.h:284
std::vector< VerneedEntry > VerneedV
Definition: ELFYAML.h:213
std::vector< StringRef > VerNames
Definition: ELFYAML.h:238
StringRef Signature
Definition: ELFYAML.h:256
std::vector< std::unique_ptr< Section > > Sections
Definition: ELFYAML.h:317
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:178
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:168
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::pair< typename base::iterator, bool > insert(StringRef Key)
Definition: StringSet.h:38
const T * data() const
Definition: ArrayRef.h:145
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
llvm::yaml::Hex8 ISARevision
Definition: ELFYAML.h:297
raw_ostream & write(unsigned char C)
static bool isMips64EL(const ELFYAML::Object &Doc)
Definition: ELFEmitter.cpp:685
size_t getOffset(CachedHashStringRef S) const
Get the offest of a string in the string table.
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1146
static Error reportError(StringRef Message)
ELF_ELFCLASS Class
Definition: ELFYAML.h:68
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
std::vector< SectionOrType > Members
Definition: ELFYAML.h:255
Optional< llvm::yaml::Hex64 > ShOffset
Definition: ELFYAML.h:159
Common declarations for yaml2obj.
StringRef str()
Return a StringRef for the vector contents.
Definition: raw_ostream.h:555
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:370
Optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:180
Optional< llvm::yaml::Hex64 > ShName
Definition: ELFYAML.h:155
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:126
bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH)
static const size_t npos
Definition: StringRef.h:50
MIPS_AFL_EXT ISAExtension
Definition: ELFYAML.h:302
#define I(x, y, z)
Definition: MD5.cpp:58
static size_t findFirstNonGlobal(ArrayRef< ELFYAML::Symbol > Symbols)
Definition: ELFEmitter.cpp:430
std::vector< VerdefEntry > Entries
Definition: ELFYAML.h:242
MIPS_AFL_FLAGS1 Flags1
Definition: ELFYAML.h:304
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:27
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:111
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:117
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
static size_t arrayDataSize(ArrayRef< T > A)
Definition: ELFEmitter.cpp:178
std::vector< uint16_t > Entries
Definition: ELFYAML.h:224
for(unsigned i=Desc.getNumOperands(), e=OldMI.getNumOperands();i !=e;++i)
const uint64_t Version
Definition: InstrProf.h:984
std::vector< Relocation > Relocations
Definition: ELFYAML.h:273
iterator end()
Definition: StringMap.h:317
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:143