LLVM  16.0.0git
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/DenseMap.h"
16 #include "llvm/ADT/SetVector.h"
17 #include "llvm/ADT/StringSet.h"
18 #include "llvm/BinaryFormat/ELF.h"
21 #include "llvm/Object/ELFTypes.h"
27 #include "llvm/Support/Errc.h"
28 #include "llvm/Support/Error.h"
29 #include "llvm/Support/LEB128.h"
31 #include "llvm/Support/WithColor.h"
34 
35 using namespace llvm;
36 
37 // This class is used to build up a contiguous binary blob while keeping
38 // track of an offset in the output (which notionally begins at
39 // `InitialOffset`).
40 // The blob might be limited to an arbitrary size. All attempts to write data
41 // are ignored and the error condition is remembered once the limit is reached.
42 // Such an approach allows us to simplify the code by delaying error reporting
43 // and doing it at a convenient time.
44 namespace {
45 class ContiguousBlobAccumulator {
46  const uint64_t InitialOffset;
47  const uint64_t MaxSize;
48 
51  Error ReachedLimitErr = Error::success();
52 
53  bool checkLimit(uint64_t Size) {
54  if (!ReachedLimitErr && getOffset() + Size <= MaxSize)
55  return true;
56  if (!ReachedLimitErr)
57  ReachedLimitErr = createStringError(errc::invalid_argument,
58  "reached the output size limit");
59  return false;
60  }
61 
62 public:
63  ContiguousBlobAccumulator(uint64_t BaseOffset, uint64_t SizeLimit)
64  : InitialOffset(BaseOffset), MaxSize(SizeLimit), OS(Buf) {}
65 
66  uint64_t tell() const { return OS.tell(); }
67  uint64_t getOffset() const { return InitialOffset + OS.tell(); }
68  void writeBlobToStream(raw_ostream &Out) const { Out << OS.str(); }
69 
70  Error takeLimitError() {
71  // Request to write 0 bytes to check we did not reach the limit.
72  checkLimit(0);
73  return std::move(ReachedLimitErr);
74  }
75 
76  /// \returns The new offset.
77  uint64_t padToAlignment(unsigned Align) {
78  uint64_t CurrentOffset = getOffset();
79  if (ReachedLimitErr)
80  return CurrentOffset;
81 
82  uint64_t AlignedOffset = alignTo(CurrentOffset, Align == 0 ? 1 : Align);
83  uint64_t PaddingSize = AlignedOffset - CurrentOffset;
84  if (!checkLimit(PaddingSize))
85  return CurrentOffset;
86 
87  writeZeros(PaddingSize);
88  return AlignedOffset;
89  }
90 
91  raw_ostream *getRawOS(uint64_t Size) {
92  if (checkLimit(Size))
93  return &OS;
94  return nullptr;
95  }
96 
97  void writeAsBinary(const yaml::BinaryRef &Bin, uint64_t N = UINT64_MAX) {
98  if (!checkLimit(Bin.binary_size()))
99  return;
100  Bin.writeAsBinary(OS, N);
101  }
102 
103  void writeZeros(uint64_t Num) {
104  if (checkLimit(Num))
105  OS.write_zeros(Num);
106  }
107 
108  void write(const char *Ptr, size_t Size) {
109  if (checkLimit(Size))
110  OS.write(Ptr, Size);
111  }
112 
113  void write(unsigned char C) {
114  if (checkLimit(1))
115  OS.write(C);
116  }
117 
118  unsigned writeULEB128(uint64_t Val) {
119  if (!checkLimit(sizeof(uint64_t)))
120  return 0;
121  return encodeULEB128(Val, OS);
122  }
123 
124  template <typename T> void write(T Val, support::endianness E) {
125  if (checkLimit(sizeof(T)))
126  support::endian::write<T>(OS, Val, E);
127  }
128 
129  void updateDataAt(uint64_t Pos, void *Data, size_t Size) {
130  assert(Pos >= InitialOffset && Pos + Size <= getOffset());
131  memcpy(&Buf[Pos - InitialOffset], Data, Size);
132  }
133 };
134 
135 // Used to keep track of section and symbol names, so that in the YAML file
136 // sections and symbols can be referenced by name instead of by index.
137 class NameToIdxMap {
139 
140 public:
141  /// \Returns false if name is already present in the map.
142  bool addName(StringRef Name, unsigned Ndx) {
143  return Map.insert({Name, Ndx}).second;
144  }
145  /// \Returns false if name is not present in the map.
146  bool lookup(StringRef Name, unsigned &Idx) const {
147  auto I = Map.find(Name);
148  if (I == Map.end())
149  return false;
150  Idx = I->getValue();
151  return true;
152  }
153  /// Asserts if name is not present in the map.
154  unsigned get(StringRef Name) const {
155  unsigned Idx;
156  if (lookup(Name, Idx))
157  return Idx;
158  assert(false && "Expected section not found in index");
159  return 0;
160  }
161  unsigned size() const { return Map.size(); }
162 };
163 
164 namespace {
165 struct Fragment {
167  uint64_t Size;
168  uint32_t Type;
169  uint64_t AddrAlign;
170 };
171 } // namespace
172 
173 /// "Single point of truth" for the ELF file construction.
174 /// TODO: This class still has a ways to go before it is truly a "single
175 /// point of truth".
176 template <class ELFT> class ELFState {
178 
179  enum class SymtabType { Static, Dynamic };
180 
181  /// The future symbol table string section.
183 
184  /// The future section header string table section, if a unique string table
185  /// is needed. Don't reference this variable direectly: use the
186  /// ShStrtabStrings member instead.
188 
189  /// The future dynamic symbol string section.
191 
192  /// The name of the section header string table section. If it is .strtab or
193  /// .dynstr, the section header strings will be written to the same string
194  /// table as the static/dynamic symbols respectively. Otherwise a dedicated
195  /// section will be created with that name.
196  StringRef SectionHeaderStringTableName = ".shstrtab";
197  StringTableBuilder *ShStrtabStrings = &DotShStrtab;
198 
199  NameToIdxMap SN2I;
200  NameToIdxMap SymN2I;
201  NameToIdxMap DynSymN2I;
202  ELFYAML::Object &Doc;
203 
204  StringSet<> ExcludedSectionHeaders;
205 
206  uint64_t LocationCounter = 0;
207  bool HasError = false;
208  yaml::ErrorHandler ErrHandler;
209  void reportError(const Twine &Msg);
210  void reportError(Error Err);
211 
212  std::vector<Elf_Sym> toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
213  const StringTableBuilder &Strtab);
214  unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
215  unsigned toSymbolIndex(StringRef S, StringRef LocSec, bool IsDynamic);
216 
217  void buildSectionIndex();
218  void buildSymbolIndexes();
219  void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
220  bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
221  StringRef SecName, ELFYAML::Section *YAMLSec);
222  void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
223  ContiguousBlobAccumulator &CBA);
224  void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
225  ContiguousBlobAccumulator &CBA,
226  ELFYAML::Section *YAMLSec);
227  void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
228  StringTableBuilder &STB,
229  ContiguousBlobAccumulator &CBA,
230  ELFYAML::Section *YAMLSec);
231  void initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
232  ContiguousBlobAccumulator &CBA,
233  ELFYAML::Section *YAMLSec);
234  void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
235  std::vector<Elf_Shdr> &SHeaders);
236 
237  std::vector<Fragment>
238  getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
240 
241  void finalizeStrings();
242  void writeELFHeader(raw_ostream &OS);
243  void writeSectionContent(Elf_Shdr &SHeader,
244  const ELFYAML::NoBitsSection &Section,
245  ContiguousBlobAccumulator &CBA);
246  void writeSectionContent(Elf_Shdr &SHeader,
247  const ELFYAML::RawContentSection &Section,
248  ContiguousBlobAccumulator &CBA);
249  void writeSectionContent(Elf_Shdr &SHeader,
250  const ELFYAML::RelocationSection &Section,
251  ContiguousBlobAccumulator &CBA);
252  void writeSectionContent(Elf_Shdr &SHeader,
253  const ELFYAML::RelrSection &Section,
254  ContiguousBlobAccumulator &CBA);
255  void writeSectionContent(Elf_Shdr &SHeader,
256  const ELFYAML::GroupSection &Group,
257  ContiguousBlobAccumulator &CBA);
258  void writeSectionContent(Elf_Shdr &SHeader,
259  const ELFYAML::SymtabShndxSection &Shndx,
260  ContiguousBlobAccumulator &CBA);
261  void writeSectionContent(Elf_Shdr &SHeader,
262  const ELFYAML::SymverSection &Section,
263  ContiguousBlobAccumulator &CBA);
264  void writeSectionContent(Elf_Shdr &SHeader,
265  const ELFYAML::VerneedSection &Section,
266  ContiguousBlobAccumulator &CBA);
267  void writeSectionContent(Elf_Shdr &SHeader,
268  const ELFYAML::VerdefSection &Section,
269  ContiguousBlobAccumulator &CBA);
270  void writeSectionContent(Elf_Shdr &SHeader,
271  const ELFYAML::ARMIndexTableSection &Section,
272  ContiguousBlobAccumulator &CBA);
273  void writeSectionContent(Elf_Shdr &SHeader,
274  const ELFYAML::MipsABIFlags &Section,
275  ContiguousBlobAccumulator &CBA);
276  void writeSectionContent(Elf_Shdr &SHeader,
277  const ELFYAML::DynamicSection &Section,
278  ContiguousBlobAccumulator &CBA);
279  void writeSectionContent(Elf_Shdr &SHeader,
280  const ELFYAML::StackSizesSection &Section,
281  ContiguousBlobAccumulator &CBA);
282  void writeSectionContent(Elf_Shdr &SHeader,
283  const ELFYAML::BBAddrMapSection &Section,
284  ContiguousBlobAccumulator &CBA);
285  void writeSectionContent(Elf_Shdr &SHeader,
286  const ELFYAML::HashSection &Section,
287  ContiguousBlobAccumulator &CBA);
288  void writeSectionContent(Elf_Shdr &SHeader,
289  const ELFYAML::AddrsigSection &Section,
290  ContiguousBlobAccumulator &CBA);
291  void writeSectionContent(Elf_Shdr &SHeader,
292  const ELFYAML::NoteSection &Section,
293  ContiguousBlobAccumulator &CBA);
294  void writeSectionContent(Elf_Shdr &SHeader,
295  const ELFYAML::GnuHashSection &Section,
296  ContiguousBlobAccumulator &CBA);
297  void writeSectionContent(Elf_Shdr &SHeader,
298  const ELFYAML::LinkerOptionsSection &Section,
299  ContiguousBlobAccumulator &CBA);
300  void writeSectionContent(Elf_Shdr &SHeader,
301  const ELFYAML::DependentLibrariesSection &Section,
302  ContiguousBlobAccumulator &CBA);
303  void writeSectionContent(Elf_Shdr &SHeader,
304  const ELFYAML::CallGraphProfileSection &Section,
305  ContiguousBlobAccumulator &CBA);
306 
307  void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
308 
309  ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
310 
311  void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
312 
313  DenseMap<StringRef, size_t> buildSectionHeaderReorderMap();
314 
315  BumpPtrAllocator StringAlloc;
316  uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
318 
319  uint64_t getSectionNameOffset(StringRef Name);
320 
321 public:
322  static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
323  yaml::ErrorHandler EH, uint64_t MaxSize);
324 };
325 } // end anonymous namespace
326 
327 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
328  return A.size() * sizeof(T);
329 }
330 
331 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
332  OS.write((const char *)A.data(), arrayDataSize(A));
333 }
334 
335 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
336 
337 template <class ELFT>
338 ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
339  : Doc(D), ErrHandler(EH) {
340  // The input may explicitly request to store the section header table strings
341  // in the same string table as dynamic or static symbol names. Set the
342  // ShStrtabStrings member accordingly.
343  if (Doc.Header.SectionHeaderStringTable) {
344  SectionHeaderStringTableName = *Doc.Header.SectionHeaderStringTable;
345  if (*Doc.Header.SectionHeaderStringTable == ".strtab")
346  ShStrtabStrings = &DotStrtab;
347  else if (*Doc.Header.SectionHeaderStringTable == ".dynstr")
348  ShStrtabStrings = &DotDynstr;
349  // Otherwise, the unique table will be used.
350  }
351 
352  std::vector<ELFYAML::Section *> Sections = Doc.getSections();
353  // Insert SHT_NULL section implicitly when it is not defined in YAML.
354  if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
355  Doc.Chunks.insert(
356  Doc.Chunks.begin(),
357  std::make_unique<ELFYAML::Section>(
358  ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
359 
360  StringSet<> DocSections;
361  ELFYAML::SectionHeaderTable *SecHdrTable = nullptr;
362  for (size_t I = 0; I < Doc.Chunks.size(); ++I) {
363  const std::unique_ptr<ELFYAML::Chunk> &C = Doc.Chunks[I];
364 
365  // We might have an explicit section header table declaration.
366  if (auto S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
367  if (SecHdrTable)
368  reportError("multiple section header tables are not allowed");
369  SecHdrTable = S;
370  continue;
371  }
372 
373  // We add a technical suffix for each unnamed section/fill. It does not
374  // affect the output, but allows us to map them by name in the code and
375  // report better error messages.
376  if (C->Name.empty()) {
377  std::string NewName = ELFYAML::appendUniqueSuffix(
378  /*Name=*/"", "index " + Twine(I));
379  C->Name = StringRef(NewName).copy(StringAlloc);
381  }
382 
383  if (!DocSections.insert(C->Name).second)
384  reportError("repeated section/fill name: '" + C->Name +
385  "' at YAML section/fill number " + Twine(I));
386  }
387 
388  SmallSetVector<StringRef, 8> ImplicitSections;
389  if (Doc.DynamicSymbols) {
390  if (SectionHeaderStringTableName == ".dynsym")
391  reportError("cannot use '.dynsym' as the section header name table when "
392  "there are dynamic symbols");
393  ImplicitSections.insert(".dynsym");
394  ImplicitSections.insert(".dynstr");
395  }
396  if (Doc.Symbols) {
397  if (SectionHeaderStringTableName == ".symtab")
398  reportError("cannot use '.symtab' as the section header name table when "
399  "there are symbols");
400  ImplicitSections.insert(".symtab");
401  }
402  if (Doc.DWARF)
403  for (StringRef DebugSecName : Doc.DWARF->getNonEmptySectionNames()) {
404  std::string SecName = ("." + DebugSecName).str();
405  // TODO: For .debug_str it should be possible to share the string table,
406  // in the same manner as the symbol string tables.
407  if (SectionHeaderStringTableName == SecName)
408  reportError("cannot use '" + SecName +
409  "' as the section header name table when it is needed for "
410  "DWARF output");
411  ImplicitSections.insert(StringRef(SecName).copy(StringAlloc));
412  }
413  // TODO: Only create the .strtab here if any symbols have been requested.
414  ImplicitSections.insert(".strtab");
415  if (!SecHdrTable || !SecHdrTable->NoHeaders.value_or(false))
416  ImplicitSections.insert(SectionHeaderStringTableName);
417 
418  // Insert placeholders for implicit sections that are not
419  // defined explicitly in YAML.
420  for (StringRef SecName : ImplicitSections) {
421  if (DocSections.count(SecName))
422  continue;
423 
424  std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
425  ELFYAML::Chunk::ChunkKind::RawContent, true /*IsImplicit*/);
426  Sec->Name = SecName;
427 
428  if (SecName == SectionHeaderStringTableName)
429  Sec->Type = ELF::SHT_STRTAB;
430  else if (SecName == ".dynsym")
431  Sec->Type = ELF::SHT_DYNSYM;
432  else if (SecName == ".symtab")
433  Sec->Type = ELF::SHT_SYMTAB;
434  else
435  Sec->Type = ELF::SHT_STRTAB;
436 
437  // When the section header table is explicitly defined at the end of the
438  // sections list, it is reasonable to assume that the user wants to reorder
439  // section headers, but still wants to place the section header table after
440  // all sections, like it normally happens. In this case we want to insert
441  // other implicit sections right before the section header table.
442  if (Doc.Chunks.back().get() == SecHdrTable)
443  Doc.Chunks.insert(Doc.Chunks.end() - 1, std::move(Sec));
444  else
445  Doc.Chunks.push_back(std::move(Sec));
446  }
447 
448  // Insert the section header table implicitly at the end, when it is not
449  // explicitly defined.
450  if (!SecHdrTable)
451  Doc.Chunks.push_back(
452  std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/true));
453 }
454 
455 template <class ELFT>
456 void ELFState<ELFT>::writeELFHeader(raw_ostream &OS) {
457  using namespace llvm::ELF;
458 
459  Elf_Ehdr Header;
460  zero(Header);
461  Header.e_ident[EI_MAG0] = 0x7f;
462  Header.e_ident[EI_MAG1] = 'E';
463  Header.e_ident[EI_MAG2] = 'L';
464  Header.e_ident[EI_MAG3] = 'F';
465  Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
466  Header.e_ident[EI_DATA] = Doc.Header.Data;
467  Header.e_ident[EI_VERSION] = EV_CURRENT;
468  Header.e_ident[EI_OSABI] = Doc.Header.OSABI;
469  Header.e_ident[EI_ABIVERSION] = Doc.Header.ABIVersion;
470  Header.e_type = Doc.Header.Type;
471 
472  if (Doc.Header.Machine)
473  Header.e_machine = *Doc.Header.Machine;
474  else
475  Header.e_machine = EM_NONE;
476 
477  Header.e_version = EV_CURRENT;
478  Header.e_entry = Doc.Header.Entry;
479  Header.e_flags = Doc.Header.Flags;
480  Header.e_ehsize = sizeof(Elf_Ehdr);
481 
482  if (Doc.Header.EPhOff)
483  Header.e_phoff = *Doc.Header.EPhOff;
484  else if (!Doc.ProgramHeaders.empty())
485  Header.e_phoff = sizeof(Header);
486  else
487  Header.e_phoff = 0;
488 
489  if (Doc.Header.EPhEntSize)
490  Header.e_phentsize = *Doc.Header.EPhEntSize;
491  else if (!Doc.ProgramHeaders.empty())
492  Header.e_phentsize = sizeof(Elf_Phdr);
493  else
494  Header.e_phentsize = 0;
495 
496  if (Doc.Header.EPhNum)
497  Header.e_phnum = *Doc.Header.EPhNum;
498  else if (!Doc.ProgramHeaders.empty())
499  Header.e_phnum = Doc.ProgramHeaders.size();
500  else
501  Header.e_phnum = 0;
502 
503  Header.e_shentsize = Doc.Header.EShEntSize ? (uint16_t)*Doc.Header.EShEntSize
504  : sizeof(Elf_Shdr);
505 
506  const ELFYAML::SectionHeaderTable &SectionHeaders =
507  Doc.getSectionHeaderTable();
508 
509  if (Doc.Header.EShOff)
510  Header.e_shoff = *Doc.Header.EShOff;
511  else if (SectionHeaders.Offset)
512  Header.e_shoff = *SectionHeaders.Offset;
513  else
514  Header.e_shoff = 0;
515 
516  if (Doc.Header.EShNum)
517  Header.e_shnum = *Doc.Header.EShNum;
518  else
519  Header.e_shnum = SectionHeaders.getNumHeaders(Doc.getSections().size());
520 
521  if (Doc.Header.EShStrNdx)
522  Header.e_shstrndx = *Doc.Header.EShStrNdx;
523  else if (SectionHeaders.Offset &&
524  !ExcludedSectionHeaders.count(SectionHeaderStringTableName))
525  Header.e_shstrndx = SN2I.get(SectionHeaderStringTableName);
526  else
527  Header.e_shstrndx = 0;
528 
529  OS.write((const char *)&Header, sizeof(Header));
530 }
531 
532 template <class ELFT>
533 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
535  DenseMap<StringRef, size_t> NameToIndex;
536  for (size_t I = 0, E = Doc.Chunks.size(); I != E; ++I) {
537  if (auto S = dyn_cast<ELFYAML::Fill>(Doc.Chunks[I].get()))
538  NameToFill[S->Name] = S;
539  NameToIndex[Doc.Chunks[I]->Name] = I + 1;
540  }
541 
542  std::vector<ELFYAML::Section *> Sections = Doc.getSections();
543  for (size_t I = 0, E = Doc.ProgramHeaders.size(); I != E; ++I) {
544  ELFYAML::ProgramHeader &YamlPhdr = Doc.ProgramHeaders[I];
545  Elf_Phdr Phdr;
546  zero(Phdr);
547  Phdr.p_type = YamlPhdr.Type;
548  Phdr.p_flags = YamlPhdr.Flags;
549  Phdr.p_vaddr = YamlPhdr.VAddr;
550  Phdr.p_paddr = YamlPhdr.PAddr;
551  PHeaders.push_back(Phdr);
552 
553  if (!YamlPhdr.FirstSec && !YamlPhdr.LastSec)
554  continue;
555 
556  // Get the index of the section, or 0 in the case when the section doesn't exist.
557  size_t First = NameToIndex[*YamlPhdr.FirstSec];
558  if (!First)
559  reportError("unknown section or fill referenced: '" + *YamlPhdr.FirstSec +
560  "' by the 'FirstSec' key of the program header with index " +
561  Twine(I));
562  size_t Last = NameToIndex[*YamlPhdr.LastSec];
563  if (!Last)
564  reportError("unknown section or fill referenced: '" + *YamlPhdr.LastSec +
565  "' by the 'LastSec' key of the program header with index " +
566  Twine(I));
567  if (!First || !Last)
568  continue;
569 
570  if (First > Last)
571  reportError("program header with index " + Twine(I) +
572  ": the section index of " + *YamlPhdr.FirstSec +
573  " is greater than the index of " + *YamlPhdr.LastSec);
574 
575  for (size_t I = First; I <= Last; ++I)
576  YamlPhdr.Chunks.push_back(Doc.Chunks[I - 1].get());
577  }
578 }
579 
580 template <class ELFT>
581 unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
582  StringRef LocSym) {
583  assert(LocSec.empty() || LocSym.empty());
584 
585  unsigned Index;
586  if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) {
587  if (!LocSym.empty())
588  reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
589  LocSym + "'");
590  else
591  reportError("unknown section referenced: '" + S + "' by YAML section '" +
592  LocSec + "'");
593  return 0;
594  }
595 
596  const ELFYAML::SectionHeaderTable &SectionHeaders =
597  Doc.getSectionHeaderTable();
598  if (SectionHeaders.IsImplicit ||
599  (SectionHeaders.NoHeaders && !*SectionHeaders.NoHeaders) ||
600  SectionHeaders.isDefault())
601  return Index;
602 
603  assert(!SectionHeaders.NoHeaders.value_or(false) || !SectionHeaders.Sections);
604  size_t FirstExcluded =
605  SectionHeaders.Sections ? SectionHeaders.Sections->size() : 0;
606  if (Index > FirstExcluded) {
607  if (LocSym.empty())
608  reportError("unable to link '" + LocSec + "' to excluded section '" + S +
609  "'");
610  else
611  reportError("excluded section referenced: '" + S + "' by symbol '" +
612  LocSym + "'");
613  }
614  return Index;
615 }
616 
617 template <class ELFT>
618 unsigned ELFState<ELFT>::toSymbolIndex(StringRef S, StringRef LocSec,
619  bool IsDynamic) {
620  const NameToIdxMap &SymMap = IsDynamic ? DynSymN2I : SymN2I;
621  unsigned Index;
622  // Here we try to look up S in the symbol table. If it is not there,
623  // treat its value as a symbol index.
624  if (!SymMap.lookup(S, Index) && !to_integer(S, Index)) {
625  reportError("unknown symbol referenced: '" + S + "' by YAML section '" +
626  LocSec + "'");
627  return 0;
628  }
629  return Index;
630 }
631 
632 template <class ELFT>
633 static void overrideFields(ELFYAML::Section *From, typename ELFT::Shdr &To) {
634  if (!From)
635  return;
636  if (From->ShAddrAlign)
637  To.sh_addralign = *From->ShAddrAlign;
638  if (From->ShFlags)
639  To.sh_flags = *From->ShFlags;
640  if (From->ShName)
641  To.sh_name = *From->ShName;
642  if (From->ShOffset)
643  To.sh_offset = *From->ShOffset;
644  if (From->ShSize)
645  To.sh_size = *From->ShSize;
646  if (From->ShType)
647  To.sh_type = *From->ShType;
648 }
649 
650 template <class ELFT>
651 bool ELFState<ELFT>::initImplicitHeader(ContiguousBlobAccumulator &CBA,
652  Elf_Shdr &Header, StringRef SecName,
653  ELFYAML::Section *YAMLSec) {
654  // Check if the header was already initialized.
655  if (Header.sh_offset)
656  return false;
657 
658  if (SecName == ".strtab")
659  initStrtabSectionHeader(Header, SecName, DotStrtab, CBA, YAMLSec);
660  else if (SecName == ".dynstr")
661  initStrtabSectionHeader(Header, SecName, DotDynstr, CBA, YAMLSec);
662  else if (SecName == SectionHeaderStringTableName)
663  initStrtabSectionHeader(Header, SecName, *ShStrtabStrings, CBA, YAMLSec);
664  else if (SecName == ".symtab")
665  initSymtabSectionHeader(Header, SymtabType::Static, CBA, YAMLSec);
666  else if (SecName == ".dynsym")
667  initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, YAMLSec);
668  else if (SecName.startswith(".debug_")) {
669  // If a ".debug_*" section's type is a preserved one, e.g., SHT_DYNAMIC, we
670  // will not treat it as a debug section.
671  if (YAMLSec && !isa<ELFYAML::RawContentSection>(YAMLSec))
672  return false;
673  initDWARFSectionHeader(Header, SecName, CBA, YAMLSec);
674  } else
675  return false;
676 
677  LocationCounter += Header.sh_size;
678 
679  // Override section fields if requested.
680  overrideFields<ELFT>(YAMLSec, Header);
681  return true;
682 }
683 
684 constexpr char SuffixStart = '(';
685 constexpr char SuffixEnd = ')';
686 
688  const Twine &Msg) {
689  // Do not add a space when a Name is empty.
690  std::string Ret = Name.empty() ? "" : Name.str() + ' ';
691  return Ret + (Twine(SuffixStart) + Msg + Twine(SuffixEnd)).str();
692 }
693 
695  if (S.empty() || S.back() != SuffixEnd)
696  return S;
697 
698  // A special case for empty names. See appendUniqueSuffix() above.
699  size_t SuffixPos = S.rfind(SuffixStart);
700  if (SuffixPos == 0)
701  return "";
702 
703  if (SuffixPos == StringRef::npos || S[SuffixPos - 1] != ' ')
704  return S;
705  return S.substr(0, SuffixPos - 1);
706 }
707 
708 template <class ELFT>
709 uint64_t ELFState<ELFT>::getSectionNameOffset(StringRef Name) {
710  // If a section is excluded from section headers, we do not save its name in
711  // the string table.
712  if (ExcludedSectionHeaders.count(Name))
713  return 0;
714  return ShStrtabStrings->getOffset(Name);
715 }
716 
717 static uint64_t writeContent(ContiguousBlobAccumulator &CBA,
720  size_t ContentSize = 0;
721  if (Content) {
722  CBA.writeAsBinary(*Content);
723  ContentSize = Content->binary_size();
724  }
725 
726  if (!Size)
727  return ContentSize;
728 
729  CBA.writeZeros(*Size - ContentSize);
730  return *Size;
731 }
732 
734  switch (SecType) {
735  case ELF::SHT_REL:
736  case ELF::SHT_RELA:
737  case ELF::SHT_GROUP:
740  return ".symtab";
741  case ELF::SHT_GNU_versym:
742  case ELF::SHT_HASH:
743  case ELF::SHT_GNU_HASH:
744  return ".dynsym";
745  case ELF::SHT_DYNSYM:
746  case ELF::SHT_GNU_verdef:
748  return ".dynstr";
749  case ELF::SHT_SYMTAB:
750  return ".strtab";
751  default:
752  return "";
753  }
754 }
755 
756 template <class ELFT>
757 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
758  ContiguousBlobAccumulator &CBA) {
759  // Ensure SHN_UNDEF entry is present. An all-zero section header is a
760  // valid SHN_UNDEF entry since SHT_NULL == 0.
761  SHeaders.resize(Doc.getSections().size());
762 
763  for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
764  if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D.get())) {
765  S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
766  writeFill(*S, CBA);
767  LocationCounter += S->Size;
768  continue;
769  }
770 
772  dyn_cast<ELFYAML::SectionHeaderTable>(D.get())) {
773  if (S->NoHeaders.value_or(false))
774  continue;
775 
776  if (!S->Offset)
777  S->Offset = alignToOffset(CBA, sizeof(typename ELFT::uint),
778  /*Offset=*/None);
779  else
780  S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
781 
782  uint64_t Size = S->getNumHeaders(SHeaders.size()) * sizeof(Elf_Shdr);
783  // The full section header information might be not available here, so
784  // fill the space with zeroes as a placeholder.
785  CBA.writeZeros(Size);
786  LocationCounter += Size;
787  continue;
788  }
789 
790  ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
791  bool IsFirstUndefSection = Sec == Doc.getSections().front();
792  if (IsFirstUndefSection && Sec->IsImplicit)
793  continue;
794 
795  Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
796  if (Sec->Link) {
797  SHeader.sh_link = toSectionIndex(*Sec->Link, Sec->Name);
798  } else {
799  StringRef LinkSec = getDefaultLinkSec(Sec->Type);
800  unsigned Link = 0;
801  if (!LinkSec.empty() && !ExcludedSectionHeaders.count(LinkSec) &&
802  SN2I.lookup(LinkSec, Link))
803  SHeader.sh_link = Link;
804  }
805 
806  if (Sec->EntSize)
807  SHeader.sh_entsize = *Sec->EntSize;
808  else
809  SHeader.sh_entsize = ELFYAML::getDefaultShEntSize<ELFT>(
810  Doc.Header.Machine.value_or(ELF::EM_NONE), Sec->Type, Sec->Name);
811 
812  // We have a few sections like string or symbol tables that are usually
813  // added implicitly to the end. However, if they are explicitly specified
814  // in the YAML, we need to write them here. This ensures the file offset
815  // remains correct.
816  if (initImplicitHeader(CBA, SHeader, Sec->Name,
817  Sec->IsImplicit ? nullptr : Sec))
818  continue;
819 
820  assert(Sec && "It can't be null unless it is an implicit section. But all "
821  "implicit sections should already have been handled above.");
822 
823  SHeader.sh_name =
824  getSectionNameOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
825  SHeader.sh_type = Sec->Type;
826  if (Sec->Flags)
827  SHeader.sh_flags = *Sec->Flags;
828  SHeader.sh_addralign = Sec->AddressAlign;
829 
830  // Set the offset for all sections, except the SHN_UNDEF section with index
831  // 0 when not explicitly requested.
832  if (!IsFirstUndefSection || Sec->Offset)
833  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, Sec->Offset);
834 
835  assignSectionAddress(SHeader, Sec);
836 
837  if (IsFirstUndefSection) {
838  if (auto RawSec = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
839  // We do not write any content for special SHN_UNDEF section.
840  if (RawSec->Size)
841  SHeader.sh_size = *RawSec->Size;
842  if (RawSec->Info)
843  SHeader.sh_info = *RawSec->Info;
844  }
845 
846  LocationCounter += SHeader.sh_size;
847  overrideFields<ELFT>(Sec, SHeader);
848  continue;
849  }
850 
851  if (!isa<ELFYAML::NoBitsSection>(Sec) && (Sec->Content || Sec->Size))
852  SHeader.sh_size = writeContent(CBA, Sec->Content, Sec->Size);
853 
854  if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
855  writeSectionContent(SHeader, *S, CBA);
856  } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
857  writeSectionContent(SHeader, *S, CBA);
858  } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
859  writeSectionContent(SHeader, *S, CBA);
860  } else if (auto S = dyn_cast<ELFYAML::RelrSection>(Sec)) {
861  writeSectionContent(SHeader, *S, CBA);
862  } else if (auto S = dyn_cast<ELFYAML::GroupSection>(Sec)) {
863  writeSectionContent(SHeader, *S, CBA);
864  } else if (auto S = dyn_cast<ELFYAML::ARMIndexTableSection>(Sec)) {
865  writeSectionContent(SHeader, *S, CBA);
866  } else if (auto S = dyn_cast<ELFYAML::MipsABIFlags>(Sec)) {
867  writeSectionContent(SHeader, *S, CBA);
868  } else if (auto S = dyn_cast<ELFYAML::NoBitsSection>(Sec)) {
869  writeSectionContent(SHeader, *S, CBA);
870  } else if (auto S = dyn_cast<ELFYAML::DynamicSection>(Sec)) {
871  writeSectionContent(SHeader, *S, CBA);
872  } else if (auto S = dyn_cast<ELFYAML::SymverSection>(Sec)) {
873  writeSectionContent(SHeader, *S, CBA);
874  } else if (auto S = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
875  writeSectionContent(SHeader, *S, CBA);
876  } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
877  writeSectionContent(SHeader, *S, CBA);
878  } else if (auto S = dyn_cast<ELFYAML::StackSizesSection>(Sec)) {
879  writeSectionContent(SHeader, *S, CBA);
880  } else if (auto S = dyn_cast<ELFYAML::HashSection>(Sec)) {
881  writeSectionContent(SHeader, *S, CBA);
882  } else if (auto S = dyn_cast<ELFYAML::AddrsigSection>(Sec)) {
883  writeSectionContent(SHeader, *S, CBA);
884  } else if (auto S = dyn_cast<ELFYAML::LinkerOptionsSection>(Sec)) {
885  writeSectionContent(SHeader, *S, CBA);
886  } else if (auto S = dyn_cast<ELFYAML::NoteSection>(Sec)) {
887  writeSectionContent(SHeader, *S, CBA);
888  } else if (auto S = dyn_cast<ELFYAML::GnuHashSection>(Sec)) {
889  writeSectionContent(SHeader, *S, CBA);
890  } else if (auto S = dyn_cast<ELFYAML::DependentLibrariesSection>(Sec)) {
891  writeSectionContent(SHeader, *S, CBA);
892  } else if (auto S = dyn_cast<ELFYAML::CallGraphProfileSection>(Sec)) {
893  writeSectionContent(SHeader, *S, CBA);
894  } else if (auto S = dyn_cast<ELFYAML::BBAddrMapSection>(Sec)) {
895  writeSectionContent(SHeader, *S, CBA);
896  } else {
897  llvm_unreachable("Unknown section type");
898  }
899 
900  LocationCounter += SHeader.sh_size;
901 
902  // Override section fields if requested.
903  overrideFields<ELFT>(Sec, SHeader);
904  }
905 }
906 
907 template <class ELFT>
908 void ELFState<ELFT>::assignSectionAddress(Elf_Shdr &SHeader,
909  ELFYAML::Section *YAMLSec) {
910  if (YAMLSec && YAMLSec->Address) {
911  SHeader.sh_addr = *YAMLSec->Address;
912  LocationCounter = *YAMLSec->Address;
913  return;
914  }
915 
916  // sh_addr represents the address in the memory image of a process. Sections
917  // in a relocatable object file or non-allocatable sections do not need
918  // sh_addr assignment.
919  if (Doc.Header.Type.value == ELF::ET_REL ||
920  !(SHeader.sh_flags & ELF::SHF_ALLOC))
921  return;
922 
923  LocationCounter =
924  alignTo(LocationCounter, SHeader.sh_addralign ? SHeader.sh_addralign : 1);
925  SHeader.sh_addr = LocationCounter;
926 }
927 
929  for (size_t I = 0; I < Symbols.size(); ++I)
930  if (Symbols[I].Binding.value != ELF::STB_LOCAL)
931  return I;
932  return Symbols.size();
933 }
934 
935 template <class ELFT>
936 std::vector<typename ELFT::Sym>
937 ELFState<ELFT>::toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
938  const StringTableBuilder &Strtab) {
939  std::vector<Elf_Sym> Ret;
940  Ret.resize(Symbols.size() + 1);
941 
942  size_t I = 0;
943  for (const ELFYAML::Symbol &Sym : Symbols) {
944  Elf_Sym &Symbol = Ret[++I];
945 
946  // If NameIndex, which contains the name offset, is explicitly specified, we
947  // use it. This is useful for preparing broken objects. Otherwise, we add
948  // the specified Name to the string table builder to get its offset.
949  if (Sym.StName)
950  Symbol.st_name = *Sym.StName;
951  else if (!Sym.Name.empty())
952  Symbol.st_name = Strtab.getOffset(ELFYAML::dropUniqueSuffix(Sym.Name));
953 
954  Symbol.setBindingAndType(Sym.Binding, Sym.Type);
955  if (Sym.Section)
956  Symbol.st_shndx = toSectionIndex(*Sym.Section, "", Sym.Name);
957  else if (Sym.Index)
958  Symbol.st_shndx = *Sym.Index;
959 
960  Symbol.st_value = Sym.Value.value_or(yaml::Hex64(0));
961  Symbol.st_other = Sym.Other ? *Sym.Other : 0;
962  Symbol.st_size = Sym.Size.value_or(yaml::Hex64(0));
963  }
964 
965  return Ret;
966 }
967 
968 template <class ELFT>
969 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
970  SymtabType STType,
971  ContiguousBlobAccumulator &CBA,
972  ELFYAML::Section *YAMLSec) {
973 
974  bool IsStatic = STType == SymtabType::Static;
976  if (IsStatic && Doc.Symbols)
977  Symbols = *Doc.Symbols;
978  else if (!IsStatic && Doc.DynamicSymbols)
979  Symbols = *Doc.DynamicSymbols;
980 
982  dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
983  if (RawSec && (RawSec->Content || RawSec->Size)) {
984  bool HasSymbolsDescription =
985  (IsStatic && Doc.Symbols) || (!IsStatic && Doc.DynamicSymbols);
986  if (HasSymbolsDescription) {
987  StringRef Property = (IsStatic ? "`Symbols`" : "`DynamicSymbols`");
988  if (RawSec->Content)
989  reportError("cannot specify both `Content` and " + Property +
990  " for symbol table section '" + RawSec->Name + "'");
991  if (RawSec->Size)
992  reportError("cannot specify both `Size` and " + Property +
993  " for symbol table section '" + RawSec->Name + "'");
994  return;
995  }
996  }
997 
998  SHeader.sh_name = getSectionNameOffset(IsStatic ? ".symtab" : ".dynsym");
999 
1000  if (YAMLSec)
1001  SHeader.sh_type = YAMLSec->Type;
1002  else
1003  SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
1004 
1005  if (YAMLSec && YAMLSec->Flags)
1006  SHeader.sh_flags = *YAMLSec->Flags;
1007  else if (!IsStatic)
1008  SHeader.sh_flags = ELF::SHF_ALLOC;
1009 
1010  // If the symbol table section is explicitly described in the YAML
1011  // then we should set the fields requested.
1012  SHeader.sh_info = (RawSec && RawSec->Info) ? (unsigned)(*RawSec->Info)
1013  : findFirstNonGlobal(Symbols) + 1;
1014  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 8;
1015 
1016  assignSectionAddress(SHeader, YAMLSec);
1017 
1018  SHeader.sh_offset =
1019  alignToOffset(CBA, SHeader.sh_addralign, RawSec ? RawSec->Offset : None);
1020 
1021  if (RawSec && (RawSec->Content || RawSec->Size)) {
1022  assert(Symbols.empty());
1023  SHeader.sh_size = writeContent(CBA, RawSec->Content, RawSec->Size);
1024  return;
1025  }
1026 
1027  std::vector<Elf_Sym> Syms =
1028  toELFSymbols(Symbols, IsStatic ? DotStrtab : DotDynstr);
1029  SHeader.sh_size = Syms.size() * sizeof(Elf_Sym);
1030  CBA.write((const char *)Syms.data(), SHeader.sh_size);
1031 }
1032 
1033 template <class ELFT>
1034 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
1035  StringTableBuilder &STB,
1036  ContiguousBlobAccumulator &CBA,
1037  ELFYAML::Section *YAMLSec) {
1038  SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
1039  SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
1040  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
1041 
1042  ELFYAML::RawContentSection *RawSec =
1043  dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
1044 
1045  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
1046  YAMLSec ? YAMLSec->Offset : None);
1047 
1048  if (RawSec && (RawSec->Content || RawSec->Size)) {
1049  SHeader.sh_size = writeContent(CBA, RawSec->Content, RawSec->Size);
1050  } else {
1051  if (raw_ostream *OS = CBA.getRawOS(STB.getSize()))
1052  STB.write(*OS);
1053  SHeader.sh_size = STB.getSize();
1054  }
1055 
1056  if (RawSec && RawSec->Info)
1057  SHeader.sh_info = *RawSec->Info;
1058 
1059  if (YAMLSec && YAMLSec->Flags)
1060  SHeader.sh_flags = *YAMLSec->Flags;
1061  else if (Name == ".dynstr")
1062  SHeader.sh_flags = ELF::SHF_ALLOC;
1063 
1064  assignSectionAddress(SHeader, YAMLSec);
1065 }
1066 
1068  SetVector<StringRef> DebugSecNames = DWARF.getNonEmptySectionNames();
1069  return Name.consume_front(".") && DebugSecNames.count(Name);
1070 }
1071 
1072 template <class ELFT>
1074  const DWARFYAML::Data &DWARF,
1075  ContiguousBlobAccumulator &CBA) {
1076  // We are unable to predict the size of debug data, so we request to write 0
1077  // bytes. This should always return us an output stream unless CBA is already
1078  // in an error state.
1079  raw_ostream *OS = CBA.getRawOS(0);
1080  if (!OS)
1081  return 0;
1082 
1083  uint64_t BeginOffset = CBA.tell();
1084 
1085  auto EmitFunc = DWARFYAML::getDWARFEmitterByName(Name.substr(1));
1086  if (Error Err = EmitFunc(*OS, DWARF))
1087  return std::move(Err);
1088 
1089  return CBA.tell() - BeginOffset;
1090 }
1091 
1092 template <class ELFT>
1093 void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
1094  ContiguousBlobAccumulator &CBA,
1095  ELFYAML::Section *YAMLSec) {
1096  SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
1097  SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
1098  SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
1099  SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
1100  YAMLSec ? YAMLSec->Offset : None);
1101 
1102  ELFYAML::RawContentSection *RawSec =
1103  dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
1104  if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
1105  if (RawSec && (RawSec->Content || RawSec->Size))
1106  reportError("cannot specify section '" + Name +
1107  "' contents in the 'DWARF' entry and the 'Content' "
1108  "or 'Size' in the 'Sections' entry at the same time");
1109  else {
1110  if (Expected<uint64_t> ShSizeOrErr =
1111  emitDWARF<ELFT>(SHeader, Name, *Doc.DWARF, CBA))
1112  SHeader.sh_size = *ShSizeOrErr;
1113  else
1114  reportError(ShSizeOrErr.takeError());
1115  }
1116  } else if (RawSec)
1117  SHeader.sh_size = writeContent(CBA, RawSec->Content, RawSec->Size);
1118  else
1119  llvm_unreachable("debug sections can only be initialized via the 'DWARF' "
1120  "entry or a RawContentSection");
1121 
1122  if (RawSec && RawSec->Info)
1123  SHeader.sh_info = *RawSec->Info;
1124 
1125  if (YAMLSec && YAMLSec->Flags)
1126  SHeader.sh_flags = *YAMLSec->Flags;
1127  else if (Name == ".debug_str")
1128  SHeader.sh_flags = ELF::SHF_MERGE | ELF::SHF_STRINGS;
1129 
1130  assignSectionAddress(SHeader, YAMLSec);
1131 }
1132 
1133 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
1134  ErrHandler(Msg);
1135  HasError = true;
1136 }
1137 
1138 template <class ELFT> void ELFState<ELFT>::reportError(Error Err) {
1139  handleAllErrors(std::move(Err), [&](const ErrorInfoBase &Err) {
1140  reportError(Err.message());
1141  });
1142 }
1143 
1144 template <class ELFT>
1145 std::vector<Fragment>
1146 ELFState<ELFT>::getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
1147  ArrayRef<Elf_Shdr> SHeaders) {
1148  std::vector<Fragment> Ret;
1149  for (const ELFYAML::Chunk *C : Phdr.Chunks) {
1150  if (const ELFYAML::Fill *F = dyn_cast<ELFYAML::Fill>(C)) {
1151  Ret.push_back({*F->Offset, F->Size, llvm::ELF::SHT_PROGBITS,
1152  /*ShAddrAlign=*/1});
1153  continue;
1154  }
1155 
1156  const ELFYAML::Section *S = cast<ELFYAML::Section>(C);
1157  const Elf_Shdr &H = SHeaders[SN2I.get(S->Name)];
1158  Ret.push_back({H.sh_offset, H.sh_size, H.sh_type, H.sh_addralign});
1159  }
1160  return Ret;
1161 }
1162 
1163 template <class ELFT>
1164 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
1165  std::vector<Elf_Shdr> &SHeaders) {
1166  uint32_t PhdrIdx = 0;
1167  for (auto &YamlPhdr : Doc.ProgramHeaders) {
1168  Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
1169  std::vector<Fragment> Fragments = getPhdrFragments(YamlPhdr, SHeaders);
1170  if (!llvm::is_sorted(Fragments, [](const Fragment &A, const Fragment &B) {
1171  return A.Offset < B.Offset;
1172  }))
1173  reportError("sections in the program header with index " +
1174  Twine(PhdrIdx) + " are not sorted by their file offset");
1175 
1176  if (YamlPhdr.Offset) {
1177  if (!Fragments.empty() && *YamlPhdr.Offset > Fragments.front().Offset)
1178  reportError("'Offset' for segment with index " + Twine(PhdrIdx) +
1179  " must be less than or equal to the minimum file offset of "
1180  "all included sections (0x" +
1181  Twine::utohexstr(Fragments.front().Offset) + ")");
1182  PHeader.p_offset = *YamlPhdr.Offset;
1183  } else if (!Fragments.empty()) {
1184  PHeader.p_offset = Fragments.front().Offset;
1185  }
1186 
1187  // Set the file size if not set explicitly.
1188  if (YamlPhdr.FileSize) {
1189  PHeader.p_filesz = *YamlPhdr.FileSize;
1190  } else if (!Fragments.empty()) {
1191  uint64_t FileSize = Fragments.back().Offset - PHeader.p_offset;
1192  // SHT_NOBITS sections occupy no physical space in a file, we should not
1193  // take their sizes into account when calculating the file size of a
1194  // segment.
1195  if (Fragments.back().Type != llvm::ELF::SHT_NOBITS)
1196  FileSize += Fragments.back().Size;
1197  PHeader.p_filesz = FileSize;
1198  }
1199 
1200  // Find the maximum offset of the end of a section in order to set p_memsz.
1201  uint64_t MemOffset = PHeader.p_offset;
1202  for (const Fragment &F : Fragments)
1203  MemOffset = std::max(MemOffset, F.Offset + F.Size);
1204  // Set the memory size if not set explicitly.
1205  PHeader.p_memsz = YamlPhdr.MemSize ? uint64_t(*YamlPhdr.MemSize)
1206  : MemOffset - PHeader.p_offset;
1207 
1208  if (YamlPhdr.Align) {
1209  PHeader.p_align = *YamlPhdr.Align;
1210  } else {
1211  // Set the alignment of the segment to be the maximum alignment of the
1212  // sections so that by default the segment has a valid and sensible
1213  // alignment.
1214  PHeader.p_align = 1;
1215  for (const Fragment &F : Fragments)
1216  PHeader.p_align = std::max((uint64_t)PHeader.p_align, F.AddrAlign);
1217  }
1218  }
1219 }
1220 
1223  for (const ELFYAML::ProgramHeader &PH : Phdrs) {
1224  auto It = llvm::find_if(
1225  PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
1226  if (std::any_of(It, PH.Chunks.end(), [](ELFYAML::Chunk *C) {
1227  return (isa<ELFYAML::Fill>(C) ||
1228  cast<ELFYAML::Section>(C)->Type != ELF::SHT_NOBITS);
1229  }))
1230  return true;
1231  }
1232  return false;
1233 }
1234 
1235 template <class ELFT>
1236 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1237  const ELFYAML::NoBitsSection &S,
1238  ContiguousBlobAccumulator &CBA) {
1239  if (!S.Size)
1240  return;
1241 
1242  SHeader.sh_size = *S.Size;
1243 
1244  // When a nobits section is followed by a non-nobits section or fill
1245  // in the same segment, we allocate the file space for it. This behavior
1246  // matches linkers.
1247  if (shouldAllocateFileSpace(Doc.ProgramHeaders, S))
1248  CBA.writeZeros(*S.Size);
1249 }
1250 
1251 template <class ELFT>
1252 void ELFState<ELFT>::writeSectionContent(
1253  Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
1254  ContiguousBlobAccumulator &CBA) {
1255  if (Section.Info)
1256  SHeader.sh_info = *Section.Info;
1257 }
1258 
1259 static bool isMips64EL(const ELFYAML::Object &Obj) {
1260  return Obj.getMachine() == llvm::ELF::EM_MIPS &&
1261  Obj.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64) &&
1262  Obj.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
1263 }
1264 
1265 template <class ELFT>
1266 void ELFState<ELFT>::writeSectionContent(
1267  Elf_Shdr &SHeader, const ELFYAML::RelocationSection &Section,
1268  ContiguousBlobAccumulator &CBA) {
1269  assert((Section.Type == llvm::ELF::SHT_REL ||
1270  Section.Type == llvm::ELF::SHT_RELA) &&
1271  "Section type is not SHT_REL nor SHT_RELA");
1272 
1273  if (!Section.RelocatableSec.empty())
1274  SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
1275 
1276  if (!Section.Relocations)
1277  return;
1278 
1279  const bool IsRela = Section.Type == llvm::ELF::SHT_RELA;
1280  for (const ELFYAML::Relocation &Rel : *Section.Relocations) {
1281  const bool IsDynamic = Section.Link && (*Section.Link == ".dynsym");
1282  unsigned SymIdx =
1283  Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name, IsDynamic) : 0;
1284  if (IsRela) {
1285  Elf_Rela REntry;
1286  zero(REntry);
1287  REntry.r_offset = Rel.Offset;
1288  REntry.r_addend = Rel.Addend;
1289  REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
1290  CBA.write((const char *)&REntry, sizeof(REntry));
1291  } else {
1292  Elf_Rel REntry;
1293  zero(REntry);
1294  REntry.r_offset = Rel.Offset;
1295  REntry.setSymbolAndType(SymIdx, Rel.Type, isMips64EL(Doc));
1296  CBA.write((const char *)&REntry, sizeof(REntry));
1297  }
1298  }
1299 
1300  SHeader.sh_size = (IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel)) *
1301  Section.Relocations->size();
1302 }
1303 
1304 template <class ELFT>
1305 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1307  ContiguousBlobAccumulator &CBA) {
1308  if (!Section.Entries)
1309  return;
1310 
1311  for (llvm::yaml::Hex64 E : *Section.Entries) {
1312  if (!ELFT::Is64Bits && E > UINT32_MAX)
1313  reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
1314  Twine::utohexstr(E));
1315  CBA.write<uintX_t>(E, ELFT::TargetEndianness);
1316  }
1317 
1318  SHeader.sh_size = sizeof(uintX_t) * Section.Entries->size();
1319 }
1320 
1321 template <class ELFT>
1322 void ELFState<ELFT>::writeSectionContent(
1323  Elf_Shdr &SHeader, const ELFYAML::SymtabShndxSection &Shndx,
1324  ContiguousBlobAccumulator &CBA) {
1325  if (Shndx.Content || Shndx.Size) {
1326  SHeader.sh_size = writeContent(CBA, Shndx.Content, Shndx.Size);
1327  return;
1328  }
1329 
1330  if (!Shndx.Entries)
1331  return;
1332 
1333  for (uint32_t E : *Shndx.Entries)
1334  CBA.write<uint32_t>(E, ELFT::TargetEndianness);
1335  SHeader.sh_size = Shndx.Entries->size() * SHeader.sh_entsize;
1336 }
1337 
1338 template <class ELFT>
1339 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1341  ContiguousBlobAccumulator &CBA) {
1343  "Section type is not SHT_GROUP");
1344 
1345  if (Section.Signature)
1346  SHeader.sh_info =
1347  toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
1348 
1349  if (!Section.Members)
1350  return;
1351 
1352  for (const ELFYAML::SectionOrType &Member : *Section.Members) {
1353  unsigned int SectionIndex = 0;
1354  if (Member.sectionNameOrType == "GRP_COMDAT")
1355  SectionIndex = llvm::ELF::GRP_COMDAT;
1356  else
1357  SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
1358  CBA.write<uint32_t>(SectionIndex, ELFT::TargetEndianness);
1359  }
1360  SHeader.sh_size = SHeader.sh_entsize * Section.Members->size();
1361 }
1362 
1363 template <class ELFT>
1364 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1366  ContiguousBlobAccumulator &CBA) {
1367  if (!Section.Entries)
1368  return;
1369 
1370  for (uint16_t Version : *Section.Entries)
1371  CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
1372  SHeader.sh_size = Section.Entries->size() * SHeader.sh_entsize;
1373 }
1374 
1375 template <class ELFT>
1376 void ELFState<ELFT>::writeSectionContent(
1377  Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
1378  ContiguousBlobAccumulator &CBA) {
1379  if (!Section.Entries)
1380  return;
1381 
1382  for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
1383  CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
1384  SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.Size);
1385  }
1386 }
1387 
1388 template <class ELFT>
1389 void ELFState<ELFT>::writeSectionContent(
1390  Elf_Shdr &SHeader, const ELFYAML::BBAddrMapSection &Section,
1391  ContiguousBlobAccumulator &CBA) {
1392  if (!Section.Entries)
1393  return;
1394 
1395  for (const ELFYAML::BBAddrMapEntry &E : *Section.Entries) {
1396  // Write version and feature values.
1398  if (E.Version > 1)
1399  WithColor::warning() << "unsupported SHT_LLVM_BB_ADDR_MAP version: "
1400  << static_cast<int>(E.Version)
1401  << "; encoding using the most recent version";
1402  CBA.write(E.Version);
1403  CBA.write(E.Feature);
1404  SHeader.sh_size += 2;
1405  }
1406  // Write the address of the function.
1407  CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
1408  // Write number of BBEntries (number of basic blocks in the function). This
1409  // is overridden by the 'NumBlocks' YAML field when specified.
1410  uint64_t NumBlocks =
1411  E.NumBlocks.value_or(E.BBEntries ? E.BBEntries->size() : 0);
1412  SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
1413  // Write all BBEntries.
1414  if (!E.BBEntries)
1415  continue;
1416  for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *E.BBEntries)
1417  SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset) +
1418  CBA.writeULEB128(BBE.Size) +
1419  CBA.writeULEB128(BBE.Metadata);
1420  }
1421 }
1422 
1423 template <class ELFT>
1424 void ELFState<ELFT>::writeSectionContent(
1425  Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
1426  ContiguousBlobAccumulator &CBA) {
1427  if (!Section.Options)
1428  return;
1429 
1430  for (const ELFYAML::LinkerOption &LO : *Section.Options) {
1431  CBA.write(LO.Key.data(), LO.Key.size());
1432  CBA.write('\0');
1433  CBA.write(LO.Value.data(), LO.Value.size());
1434  CBA.write('\0');
1435  SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
1436  }
1437 }
1438 
1439 template <class ELFT>
1440 void ELFState<ELFT>::writeSectionContent(
1441  Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
1442  ContiguousBlobAccumulator &CBA) {
1443  if (!Section.Libs)
1444  return;
1445 
1446  for (StringRef Lib : *Section.Libs) {
1447  CBA.write(Lib.data(), Lib.size());
1448  CBA.write('\0');
1449  SHeader.sh_size += Lib.size() + 1;
1450  }
1451 }
1452 
1453 template <class ELFT>
1454 uint64_t
1455 ELFState<ELFT>::alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
1457  uint64_t CurrentOffset = CBA.getOffset();
1458  uint64_t AlignedOffset;
1459 
1460  if (Offset) {
1461  if ((uint64_t)*Offset < CurrentOffset) {
1462  reportError("the 'Offset' value (0x" +
1463  Twine::utohexstr((uint64_t)*Offset) + ") goes backward");
1464  return CurrentOffset;
1465  }
1466 
1467  // We ignore an alignment when an explicit offset has been requested.
1468  AlignedOffset = *Offset;
1469  } else {
1470  AlignedOffset = alignTo(CurrentOffset, std::max(Align, (uint64_t)1));
1471  }
1472 
1473  CBA.writeZeros(AlignedOffset - CurrentOffset);
1474  return AlignedOffset;
1475 }
1476 
1477 template <class ELFT>
1478 void ELFState<ELFT>::writeSectionContent(
1479  Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
1480  ContiguousBlobAccumulator &CBA) {
1481  if (!Section.Entries)
1482  return;
1483 
1484  for (const ELFYAML::CallGraphEntryWeight &E : *Section.Entries) {
1485  CBA.write<uint64_t>(E.Weight, ELFT::TargetEndianness);
1486  SHeader.sh_size += sizeof(object::Elf_CGProfile_Impl<ELFT>);
1487  }
1488 }
1489 
1490 template <class ELFT>
1491 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1493  ContiguousBlobAccumulator &CBA) {
1494  if (!Section.Bucket)
1495  return;
1496 
1497  CBA.write<uint32_t>(
1498  Section.NBucket.value_or(llvm::yaml::Hex64(Section.Bucket->size())),
1499  ELFT::TargetEndianness);
1500  CBA.write<uint32_t>(
1501  Section.NChain.value_or(llvm::yaml::Hex64(Section.Chain->size())),
1502  ELFT::TargetEndianness);
1503 
1504  for (uint32_t Val : *Section.Bucket)
1505  CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1506  for (uint32_t Val : *Section.Chain)
1507  CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1508 
1509  SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
1510 }
1511 
1512 template <class ELFT>
1513 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1515  ContiguousBlobAccumulator &CBA) {
1516 
1517  if (Section.Info)
1518  SHeader.sh_info = *Section.Info;
1519  else if (Section.Entries)
1520  SHeader.sh_info = Section.Entries->size();
1521 
1522  if (!Section.Entries)
1523  return;
1524 
1525  uint64_t AuxCnt = 0;
1526  for (size_t I = 0; I < Section.Entries->size(); ++I) {
1527  const ELFYAML::VerdefEntry &E = (*Section.Entries)[I];
1528 
1529  Elf_Verdef VerDef;
1530  VerDef.vd_version = E.Version.value_or(1);
1531  VerDef.vd_flags = E.Flags.value_or(0);
1532  VerDef.vd_ndx = E.VersionNdx.value_or(0);
1533  VerDef.vd_hash = E.Hash.value_or(0);
1534  VerDef.vd_aux = sizeof(Elf_Verdef);
1535  VerDef.vd_cnt = E.VerNames.size();
1536  if (I == Section.Entries->size() - 1)
1537  VerDef.vd_next = 0;
1538  else
1539  VerDef.vd_next =
1540  sizeof(Elf_Verdef) + E.VerNames.size() * sizeof(Elf_Verdaux);
1541  CBA.write((const char *)&VerDef, sizeof(Elf_Verdef));
1542 
1543  for (size_t J = 0; J < E.VerNames.size(); ++J, ++AuxCnt) {
1544  Elf_Verdaux VernAux;
1545  VernAux.vda_name = DotDynstr.getOffset(E.VerNames[J]);
1546  if (J == E.VerNames.size() - 1)
1547  VernAux.vda_next = 0;
1548  else
1549  VernAux.vda_next = sizeof(Elf_Verdaux);
1550  CBA.write((const char *)&VernAux, sizeof(Elf_Verdaux));
1551  }
1552  }
1553 
1554  SHeader.sh_size = Section.Entries->size() * sizeof(Elf_Verdef) +
1555  AuxCnt * sizeof(Elf_Verdaux);
1556 }
1557 
1558 template <class ELFT>
1559 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1561  ContiguousBlobAccumulator &CBA) {
1562  if (Section.Info)
1563  SHeader.sh_info = *Section.Info;
1564  else if (Section.VerneedV)
1565  SHeader.sh_info = Section.VerneedV->size();
1566 
1567  if (!Section.VerneedV)
1568  return;
1569 
1570  uint64_t AuxCnt = 0;
1571  for (size_t I = 0; I < Section.VerneedV->size(); ++I) {
1572  const ELFYAML::VerneedEntry &VE = (*Section.VerneedV)[I];
1573 
1574  Elf_Verneed VerNeed;
1575  VerNeed.vn_version = VE.Version;
1576  VerNeed.vn_file = DotDynstr.getOffset(VE.File);
1577  if (I == Section.VerneedV->size() - 1)
1578  VerNeed.vn_next = 0;
1579  else
1580  VerNeed.vn_next =
1581  sizeof(Elf_Verneed) + VE.AuxV.size() * sizeof(Elf_Vernaux);
1582  VerNeed.vn_cnt = VE.AuxV.size();
1583  VerNeed.vn_aux = sizeof(Elf_Verneed);
1584  CBA.write((const char *)&VerNeed, sizeof(Elf_Verneed));
1585 
1586  for (size_t J = 0; J < VE.AuxV.size(); ++J, ++AuxCnt) {
1587  const ELFYAML::VernauxEntry &VAuxE = VE.AuxV[J];
1588 
1589  Elf_Vernaux VernAux;
1590  VernAux.vna_hash = VAuxE.Hash;
1591  VernAux.vna_flags = VAuxE.Flags;
1592  VernAux.vna_other = VAuxE.Other;
1593  VernAux.vna_name = DotDynstr.getOffset(VAuxE.Name);
1594  if (J == VE.AuxV.size() - 1)
1595  VernAux.vna_next = 0;
1596  else
1597  VernAux.vna_next = sizeof(Elf_Vernaux);
1598  CBA.write((const char *)&VernAux, sizeof(Elf_Vernaux));
1599  }
1600  }
1601 
1602  SHeader.sh_size = Section.VerneedV->size() * sizeof(Elf_Verneed) +
1603  AuxCnt * sizeof(Elf_Vernaux);
1604 }
1605 
1606 template <class ELFT>
1607 void ELFState<ELFT>::writeSectionContent(
1608  Elf_Shdr &SHeader, const ELFYAML::ARMIndexTableSection &Section,
1609  ContiguousBlobAccumulator &CBA) {
1610  if (!Section.Entries)
1611  return;
1612 
1613  for (const ELFYAML::ARMIndexTableEntry &E : *Section.Entries) {
1614  CBA.write<uint32_t>(E.Offset, ELFT::TargetEndianness);
1615  CBA.write<uint32_t>(E.Value, ELFT::TargetEndianness);
1616  }
1617  SHeader.sh_size = Section.Entries->size() * 8;
1618 }
1619 
1620 template <class ELFT>
1621 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1623  ContiguousBlobAccumulator &CBA) {
1625  "Section type is not SHT_MIPS_ABIFLAGS");
1626 
1628  zero(Flags);
1629  SHeader.sh_size = SHeader.sh_entsize;
1630 
1631  Flags.version = Section.Version;
1632  Flags.isa_level = Section.ISALevel;
1633  Flags.isa_rev = Section.ISARevision;
1634  Flags.gpr_size = Section.GPRSize;
1635  Flags.cpr1_size = Section.CPR1Size;
1636  Flags.cpr2_size = Section.CPR2Size;
1637  Flags.fp_abi = Section.FpABI;
1638  Flags.isa_ext = Section.ISAExtension;
1639  Flags.ases = Section.ASEs;
1640  Flags.flags1 = Section.Flags1;
1641  Flags.flags2 = Section.Flags2;
1642  CBA.write((const char *)&Flags, sizeof(Flags));
1643 }
1644 
1645 template <class ELFT>
1646 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1648  ContiguousBlobAccumulator &CBA) {
1650  "Section type is not SHT_DYNAMIC");
1651 
1652  if (!Section.Entries)
1653  return;
1654 
1655  for (const ELFYAML::DynamicEntry &DE : *Section.Entries) {
1656  CBA.write<uintX_t>(DE.Tag, ELFT::TargetEndianness);
1657  CBA.write<uintX_t>(DE.Val, ELFT::TargetEndianness);
1658  }
1659  SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
1660 }
1661 
1662 template <class ELFT>
1663 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1665  ContiguousBlobAccumulator &CBA) {
1666  if (!Section.Symbols)
1667  return;
1668 
1669  for (StringRef Sym : *Section.Symbols)
1670  SHeader.sh_size +=
1671  CBA.writeULEB128(toSymbolIndex(Sym, Section.Name, /*IsDynamic=*/false));
1672 }
1673 
1674 template <class ELFT>
1675 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1677  ContiguousBlobAccumulator &CBA) {
1678  if (!Section.Notes)
1679  return;
1680 
1681  uint64_t Offset = CBA.tell();
1682  for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
1683  // Write name size.
1684  if (NE.Name.empty())
1685  CBA.write<uint32_t>(0, ELFT::TargetEndianness);
1686  else
1687  CBA.write<uint32_t>(NE.Name.size() + 1, ELFT::TargetEndianness);
1688 
1689  // Write description size.
1690  if (NE.Desc.binary_size() == 0)
1691  CBA.write<uint32_t>(0, ELFT::TargetEndianness);
1692  else
1693  CBA.write<uint32_t>(NE.Desc.binary_size(), ELFT::TargetEndianness);
1694 
1695  // Write type.
1696  CBA.write<uint32_t>(NE.Type, ELFT::TargetEndianness);
1697 
1698  // Write name, null terminator and padding.
1699  if (!NE.Name.empty()) {
1700  CBA.write(NE.Name.data(), NE.Name.size());
1701  CBA.write('\0');
1702  CBA.padToAlignment(4);
1703  }
1704 
1705  // Write description and padding.
1706  if (NE.Desc.binary_size() != 0) {
1707  CBA.writeAsBinary(NE.Desc);
1708  CBA.padToAlignment(4);
1709  }
1710  }
1711 
1712  SHeader.sh_size = CBA.tell() - Offset;
1713 }
1714 
1715 template <class ELFT>
1716 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1718  ContiguousBlobAccumulator &CBA) {
1719  if (!Section.HashBuckets)
1720  return;
1721 
1722  if (!Section.Header)
1723  return;
1724 
1725  // We write the header first, starting with the hash buckets count. Normally
1726  // it is the number of entries in HashBuckets, but the "NBuckets" property can
1727  // be used to override this field, which is useful for producing broken
1728  // objects.
1729  if (Section.Header->NBuckets)
1730  CBA.write<uint32_t>(*Section.Header->NBuckets, ELFT::TargetEndianness);
1731  else
1732  CBA.write<uint32_t>(Section.HashBuckets->size(), ELFT::TargetEndianness);
1733 
1734  // Write the index of the first symbol in the dynamic symbol table accessible
1735  // via the hash table.
1736  CBA.write<uint32_t>(Section.Header->SymNdx, ELFT::TargetEndianness);
1737 
1738  // Write the number of words in the Bloom filter. As above, the "MaskWords"
1739  // property can be used to set this field to any value.
1740  if (Section.Header->MaskWords)
1741  CBA.write<uint32_t>(*Section.Header->MaskWords, ELFT::TargetEndianness);
1742  else
1743  CBA.write<uint32_t>(Section.BloomFilter->size(), ELFT::TargetEndianness);
1744 
1745  // Write the shift constant used by the Bloom filter.
1746  CBA.write<uint32_t>(Section.Header->Shift2, ELFT::TargetEndianness);
1747 
1748  // We've finished writing the header. Now write the Bloom filter.
1749  for (llvm::yaml::Hex64 Val : *Section.BloomFilter)
1750  CBA.write<uintX_t>(Val, ELFT::TargetEndianness);
1751 
1752  // Write an array of hash buckets.
1753  for (llvm::yaml::Hex32 Val : *Section.HashBuckets)
1754  CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1755 
1756  // Write an array of hash values.
1757  for (llvm::yaml::Hex32 Val : *Section.HashValues)
1758  CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1759 
1760  SHeader.sh_size = 16 /*Header size*/ +
1761  Section.BloomFilter->size() * sizeof(typename ELFT::uint) +
1762  Section.HashBuckets->size() * 4 +
1763  Section.HashValues->size() * 4;
1764 }
1765 
1766 template <class ELFT>
1767 void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
1768  ContiguousBlobAccumulator &CBA) {
1769  size_t PatternSize = Fill.Pattern ? Fill.Pattern->binary_size() : 0;
1770  if (!PatternSize) {
1771  CBA.writeZeros(Fill.Size);
1772  return;
1773  }
1774 
1775  // Fill the content with the specified pattern.
1776  uint64_t Written = 0;
1777  for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
1778  CBA.writeAsBinary(*Fill.Pattern);
1779  CBA.writeAsBinary(*Fill.Pattern, Fill.Size - Written);
1780 }
1781 
1782 template <class ELFT>
1783 DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
1784  const ELFYAML::SectionHeaderTable &SectionHeaders =
1785  Doc.getSectionHeaderTable();
1786  if (SectionHeaders.IsImplicit || SectionHeaders.NoHeaders ||
1787  SectionHeaders.isDefault())
1788  return DenseMap<StringRef, size_t>();
1789 
1791  size_t SecNdx = 0;
1792  StringSet<> Seen;
1793 
1794  auto AddSection = [&](const ELFYAML::SectionHeader &Hdr) {
1795  if (!Ret.try_emplace(Hdr.Name, ++SecNdx).second)
1796  reportError("repeated section name: '" + Hdr.Name +
1797  "' in the section header description");
1798  Seen.insert(Hdr.Name);
1799  };
1800 
1801  if (SectionHeaders.Sections)
1802  for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Sections)
1803  AddSection(Hdr);
1804 
1805  if (SectionHeaders.Excluded)
1806  for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
1807  AddSection(Hdr);
1808 
1809  for (const ELFYAML::Section *S : Doc.getSections()) {
1810  // Ignore special first SHT_NULL section.
1811  if (S == Doc.getSections().front())
1812  continue;
1813  if (!Seen.count(S->Name))
1814  reportError("section '" + S->Name +
1815  "' should be present in the 'Sections' or 'Excluded' lists");
1816  Seen.erase(S->Name);
1817  }
1818 
1819  for (const auto &It : Seen)
1820  reportError("section header contains undefined section '" + It.getKey() +
1821  "'");
1822  return Ret;
1823 }
1824 
1825 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
1826  // A YAML description can have an explicit section header declaration that
1827  // allows to change the order of section headers.
1828  DenseMap<StringRef, size_t> ReorderMap = buildSectionHeaderReorderMap();
1829 
1830  if (HasError)
1831  return;
1832 
1833  // Build excluded section headers map.
1834  std::vector<ELFYAML::Section *> Sections = Doc.getSections();
1835  const ELFYAML::SectionHeaderTable &SectionHeaders =
1836  Doc.getSectionHeaderTable();
1837  if (SectionHeaders.Excluded)
1838  for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
1839  if (!ExcludedSectionHeaders.insert(Hdr.Name).second)
1840  llvm_unreachable("buildSectionIndex() failed");
1841 
1842  if (SectionHeaders.NoHeaders.value_or(false))
1843  for (const ELFYAML::Section *S : Sections)
1844  if (!ExcludedSectionHeaders.insert(S->Name).second)
1845  llvm_unreachable("buildSectionIndex() failed");
1846 
1847  size_t SecNdx = -1;
1848  for (const ELFYAML::Section *S : Sections) {
1849  ++SecNdx;
1850 
1851  size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(S->Name);
1852  if (!SN2I.addName(S->Name, Index))
1853  llvm_unreachable("buildSectionIndex() failed");
1854 
1855  if (!ExcludedSectionHeaders.count(S->Name))
1856  ShStrtabStrings->add(ELFYAML::dropUniqueSuffix(S->Name));
1857  }
1858 }
1859 
1860 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {
1861  auto Build = [this](ArrayRef<ELFYAML::Symbol> V, NameToIdxMap &Map) {
1862  for (size_t I = 0, S = V.size(); I < S; ++I) {
1863  const ELFYAML::Symbol &Sym = V[I];
1864  if (!Sym.Name.empty() && !Map.addName(Sym.Name, I + 1))
1865  reportError("repeated symbol name: '" + Sym.Name + "'");
1866  }
1867  };
1868 
1869  if (Doc.Symbols)
1870  Build(*Doc.Symbols, SymN2I);
1871  if (Doc.DynamicSymbols)
1872  Build(*Doc.DynamicSymbols, DynSymN2I);
1873 }
1874 
1875 template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
1876  // Add the regular symbol names to .strtab section.
1877  if (Doc.Symbols)
1878  for (const ELFYAML::Symbol &Sym : *Doc.Symbols)
1879  DotStrtab.add(ELFYAML::dropUniqueSuffix(Sym.Name));
1880  DotStrtab.finalize();
1881 
1882  // Add the dynamic symbol names to .dynstr section.
1883  if (Doc.DynamicSymbols)
1884  for (const ELFYAML::Symbol &Sym : *Doc.DynamicSymbols)
1885  DotDynstr.add(ELFYAML::dropUniqueSuffix(Sym.Name));
1886 
1887  // SHT_GNU_verdef and SHT_GNU_verneed sections might also
1888  // add strings to .dynstr section.
1889  for (const ELFYAML::Chunk *Sec : Doc.getSections()) {
1890  if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
1891  if (VerNeed->VerneedV) {
1892  for (const ELFYAML::VerneedEntry &VE : *VerNeed->VerneedV) {
1893  DotDynstr.add(VE.File);
1894  for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
1895  DotDynstr.add(Aux.Name);
1896  }
1897  }
1898  } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
1899  if (VerDef->Entries)
1900  for (const ELFYAML::VerdefEntry &E : *VerDef->Entries)
1901  for (StringRef Name : E.VerNames)
1902  DotDynstr.add(Name);
1903  }
1904  }
1905 
1906  DotDynstr.finalize();
1907 
1908  // Don't finalize the section header string table a second time if it has
1909  // already been finalized due to being one of the symbol string tables.
1910  if (ShStrtabStrings != &DotStrtab && ShStrtabStrings != &DotDynstr)
1911  ShStrtabStrings->finalize();
1912 }
1913 
1914 template <class ELFT>
1915 bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
1916  yaml::ErrorHandler EH, uint64_t MaxSize) {
1917  ELFState<ELFT> State(Doc, EH);
1918  if (State.HasError)
1919  return false;
1920 
1921  // Build the section index, which adds sections to the section header string
1922  // table first, so that we can finalize the section header string table.
1923  State.buildSectionIndex();
1924  State.buildSymbolIndexes();
1925 
1926  // Finalize section header string table and the .strtab and .dynstr sections.
1927  // We do this early because we want to finalize the string table builders
1928  // before writing the content of the sections that might want to use them.
1929  State.finalizeStrings();
1930 
1931  if (State.HasError)
1932  return false;
1933 
1934  std::vector<Elf_Phdr> PHeaders;
1935  State.initProgramHeaders(PHeaders);
1936 
1937  // XXX: This offset is tightly coupled with the order that we write
1938  // things to `OS`.
1939  const size_t SectionContentBeginOffset =
1940  sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
1941  // It is quite easy to accidentally create output with yaml2obj that is larger
1942  // than intended, for example, due to an issue in the YAML description.
1943  // We limit the maximum allowed output size, but also provide a command line
1944  // option to change this limitation.
1945  ContiguousBlobAccumulator CBA(SectionContentBeginOffset, MaxSize);
1946 
1947  std::vector<Elf_Shdr> SHeaders;
1948  State.initSectionHeaders(SHeaders, CBA);
1949 
1950  // Now we can decide segment offsets.
1951  State.setProgramHeaderLayout(PHeaders, SHeaders);
1952 
1953  bool ReachedLimit = CBA.getOffset() > MaxSize;
1954  if (Error E = CBA.takeLimitError()) {
1955  // We report a custom error message instead below.
1957  ReachedLimit = true;
1958  }
1959 
1960  if (ReachedLimit)
1961  State.reportError(
1962  "the desired output size is greater than permitted. Use the "
1963  "--max-size option to change the limit");
1964 
1965  if (State.HasError)
1966  return false;
1967 
1968  State.writeELFHeader(OS);
1969  writeArrayData(OS, makeArrayRef(PHeaders));
1970 
1972  if (!SHT.NoHeaders.value_or(false))
1973  CBA.updateDataAt(*SHT.Offset, SHeaders.data(),
1974  SHT.getNumHeaders(SHeaders.size()) * sizeof(Elf_Shdr));
1975 
1976  CBA.writeBlobToStream(OS);
1977  return true;
1978 }
1979 
1980 namespace llvm {
1981 namespace yaml {
1982 
1984  uint64_t MaxSize) {
1985  bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
1986  bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
1987  if (Is64Bit) {
1988  if (IsLE)
1989  return ELFState<object::ELF64LE>::writeELF(Out, Doc, EH, MaxSize);
1990  return ELFState<object::ELF64BE>::writeELF(Out, Doc, EH, MaxSize);
1991  }
1992  if (IsLE)
1993  return ELFState<object::ELF32LE>::writeELF(Out, Doc, EH, MaxSize);
1994  return ELFState<object::ELF32BE>::writeELF(Out, Doc, EH, MaxSize);
1995 }
1996 
1997 } // namespace yaml
1998 } // namespace llvm
llvm::Check::Size
@ Size
Definition: FileCheck.h:77
alignTo
static int alignTo(int Num, int PowOf2)
Definition: AArch64LoadStoreOptimizer.cpp:1203
MemoryBuffer.h
llvm::ELFYAML::Relocation::Symbol
Optional< StringRef > Symbol
Definition: ELFYAML.h:592
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::raw_ostream::tell
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:134
llvm::errc::invalid_argument
@ invalid_argument
llvm::ELFYAML::Section::Flags
Optional< ELF_SHF > Flags
Definition: ELFYAML.h:226
llvm::ELF::SHT_GROUP
@ SHT_GROUP
Definition: ELF.h:994
llvm::AArch64CC::LO
@ LO
Definition: AArch64BaseInfo.h:258
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::ELFYAML::NoteSection
Definition: ELFYAML.h:379
llvm::ELFYAML::shouldAllocateFileSpace
bool shouldAllocateFileSpace(ArrayRef< ProgramHeader > Phdrs, const NoBitsSection &S)
Definition: ELFEmitter.cpp:1221
llvm::ELFYAML::SectionHeaderTable::Sections
Optional< std::vector< SectionHeader > > Sections
Definition: ELFYAML.h:299
llvm::AArch64CC::NE
@ NE
Definition: AArch64BaseInfo.h:256
llvm::ELFYAML::ProgramHeader::Chunks
std::vector< Chunk * > Chunks
Definition: ELFYAML.h:691
llvm::ELF::EI_DATA
@ EI_DATA
Definition: ELF.h:53
writeContent
static uint64_t writeContent(ContiguousBlobAccumulator &CBA, const Optional< yaml::BinaryRef > &Content, const Optional< llvm::yaml::Hex64 > &Size)
Definition: ELFEmitter.cpp:717
llvm::ELFYAML::Fill
Definition: ELFYAML.h:282
llvm::pdb::PDB_DataKind::Member
@ Member
llvm::raw_ostream::write_zeros
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert 'NumZeros' nulls.
Definition: raw_ostream.cpp:499
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::lookup
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:197
llvm::PseudoProbeReservedId::Last
@ Last
SizeLimit
static cl::opt< unsigned > SizeLimit("eif-limit", cl::init(6), cl::Hidden, cl::desc("Size limit in Hexagon early if-conversion"))
llvm::ELFYAML::Relocation::Offset
llvm::yaml::Hex64 Offset
Definition: ELFYAML.h:589
llvm::ELF::SHT_GNU_verdef
@ SHT_GNU_verdef
Definition: ELF.h:1024
llvm::write
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:549
llvm::ELFYAML::CallGraphProfileSection
Definition: ELFYAML.h:526
llvm::ELFYAML::LinkerOption
Definition: ELFYAML.h:487
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
llvm::ELFYAML::VerdefEntry
Definition: ELFYAML.h:552
llvm::ELFYAML::VernauxEntry::Name
StringRef Name
Definition: ELFYAML.h:451
llvm::ELFYAML::GroupSection
Definition: ELFYAML.h:573
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::ELF::SHT_HASH
@ SHT_HASH
Definition: ELF.h:984
llvm::ELFYAML::Symbol::Name
StringRef Name
Definition: ELFYAML.h:137
llvm::ELFYAML::NoBitsSection
Definition: ELFYAML.h:373
Content
T Content
Definition: ELFObjHandler.cpp:88
Error.h
llvm::ELF::SHT_DYNSYM
@ SHT_DYNSYM
Definition: ELF.h:990
llvm::ELFYAML::ProgramHeader
Definition: ELFYAML.h:678
llvm::ELF::SHT_NOBITS
@ SHT_NOBITS
Definition: ELF.h:987
Errc.h
llvm::ELF::EM_NONE
@ EM_NONE
Definition: ELF.h:133
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
llvm::ELF::SHT_SYMTAB
@ SHT_SYMTAB
Definition: ELF.h:981
llvm::ELFYAML::Chunk::Offset
Optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:214
llvm::ELF::SHF_MERGE
@ SHF_MERGE
Definition: ELF.h:1070
llvm::ELFYAML::Section::Address
Optional< llvm::yaml::Hex64 > Address
Definition: ELFYAML.h:227
llvm::object::Elf_Mips_ABIFlags
Definition: ELFTypes.h:782
llvm::Optional< llvm::yaml::Hex64 >
llvm::ELFYAML::AddrsigSection
Definition: ELFYAML.h:475
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:79
SuffixEnd
constexpr char SuffixEnd
Definition: ELFEmitter.cpp:685
llvm::ELF::SHT_PROGBITS
@ SHT_PROGBITS
Definition: ELF.h:980
llvm::ELF::SHT_GNU_versym
@ SHT_GNU_versym
Definition: ELF.h:1026
llvm::ELFYAML::Fill::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:284
llvm::ELFYAML::SectionHeader::Name
StringRef Name
Definition: ELFYAML.h:133
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::StringSet::insert
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:34
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:119
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::ELF::SHT_STRTAB
@ SHT_STRTAB
Definition: ELF.h:982
llvm::codeview::Link
@ Link
Definition: CodeView.h:151
warning
transform warning
Definition: WarnMissedTransforms.cpp:145
llvm::ELFYAML::RawContentSection
Definition: ELFYAML.h:360
llvm::StringTableBuilder::getOffset
size_t getOffset(CachedHashStringRef S) const
Get the offest of a string in the string table.
Definition: StringTableBuilder.cpp:194
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1042
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
llvm::getOffset
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
Definition: RuntimeDyld.cpp:172
llvm::ELF
Definition: ELF.h:27
llvm::ELFYAML::SectionHeader
Definition: ELFYAML.h:132
llvm::DWARFYAML::Data
Definition: DWARFYAML.h:210
llvm::ELFYAML::VernauxEntry::Hash
uint32_t Hash
Definition: ELFYAML.h:448
F
#define F(x, y, z)
Definition: MD5.cpp:55
uint
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint
Definition: README.txt:239
llvm::SubDirectoryType::Bin
@ Bin
findFirstNonGlobal
static size_t findFirstNonGlobal(ArrayRef< ELFYAML::Symbol > Symbols)
Definition: ELFEmitter.cpp:928
llvm::ELFYAML::SectionHeaderTable::getNumHeaders
size_t getNumHeaders(size_t SectionsNum) const
Definition: ELFYAML.h:303
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
StringTableBuilder.h
ELF.h
llvm::StringRef::startswith
bool startswith(StringRef Prefix) const
Definition: StringRef.h:260
llvm::ELFYAML::SectionHeaderTable::isDefault
bool isDefault() const
Definition: ELFYAML.h:311
llvm::ELFYAML::Section::EntSize
Optional< llvm::yaml::Hex64 > EntSize
Definition: ELFYAML.h:230
llvm::msgpack::Type::Map
@ Map
llvm::ELFYAML::Relocation
Definition: ELFYAML.h:588
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ELFYAML::VerneedEntry
Definition: ELFYAML.h:454
ELFYAML.h
reportError
static Error reportError(StringRef Message)
Definition: BitcodeAnalyzer.cpp:19
llvm::SubDirectoryType::Lib
@ Lib
llvm::ELFYAML::VerneedEntry::File
StringRef File
Definition: ELFYAML.h:456
llvm::ELF::EI_MAG1
@ EI_MAG1
Definition: ELF.h:49
UINT64_MAX
#define UINT64_MAX
Definition: DataTypes.h:77
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
First
into llvm powi allowing the code generator to produce balanced multiplication trees First
Definition: README.txt:54
arrayDataSize
static size_t arrayDataSize(ArrayRef< T > A)
Definition: ELFEmitter.cpp:327
llvm::ELFYAML::GnuHashSection
Definition: ELFYAML.h:429
llvm::StringTableBuilder::getSize
size_t getSize() const
Definition: StringTableBuilder.h:82
llvm::yaml::yaml2elf
bool yaml2elf(ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH, uint64_t MaxSize)
Definition: ELFEmitter.cpp:1983
llvm::raw_ostream::write
raw_ostream & write(unsigned char C)
Definition: raw_ostream.cpp:218
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::ELFYAML::RelocationSection
Definition: ELFYAML.h:595
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:1056
llvm::ELF::SHT_MIPS_ABIFLAGS
@ SHT_MIPS_ABIFLAGS
Definition: ELF.h:1045
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::ErrorInfoBase
Base class for error info classes.
Definition: Error.h:46
llvm::StringMap< unsigned >
llvm::ELFYAML::DynamicEntry::Tag
ELF_DYNTAG Tag
Definition: ELFYAML.h:154
llvm::ELFYAML::BBAddrMapEntry::BBEntry::Size
llvm::yaml::Hex64 Size
Definition: ELFYAML.h:161
llvm::ELFYAML::SymverSection
Definition: ELFYAML.h:540
llvm::ELFYAML::dropUniqueSuffix
StringRef dropUniqueSuffix(StringRef S)
Definition: ELFEmitter.cpp:694
llvm::ELFYAML::ProgramHeader::LastSec
Optional< StringRef > LastSec
Definition: ELFYAML.h:688
DWARFYAML.h
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::ELFYAML::Object
Definition: ELFYAML.h:694
llvm::DWARFYAML::Data::getNonEmptySectionNames
SetVector< StringRef > getNonEmptySectionNames() const
Definition: DWARFYAML.cpp:25
llvm::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
llvm::ELFYAML::SectionHeaderTable::NoHeaders
Optional< bool > NoHeaders
Definition: ELFYAML.h:301
llvm::ELF::EI_OSABI
@ EI_OSABI
Definition: ELF.h:55
llvm::ELFYAML::Fill::Pattern
Optional< yaml::BinaryRef > Pattern
Definition: ELFYAML.h:283
llvm::ELFYAML::Object::getMachine
unsigned getMachine() const
Definition: ELFYAML.cpp:34
llvm::ELF::SHT_GNU_HASH
@ SHT_GNU_HASH
Definition: ELF.h:1023
llvm::ELFYAML::appendUniqueSuffix
std::string appendUniqueSuffix(StringRef Name, const Twine &Msg)
Definition: ELFEmitter.cpp:687
llvm::ELFYAML::SymtabShndxSection::Entries
Optional< std::vector< uint32_t > > Entries
Definition: ELFYAML.h:625
llvm::ELFYAML::SectionOrType
Definition: ELFYAML.h:149
llvm::AMDGPU::Hwreg::Offset
Offset
Definition: SIDefines.h:416
Index
uint32_t Index
Definition: ELFObjHandler.cpp:82
llvm::StringMap< std::nullopt_t, MallocAllocator >::erase
void erase(iterator I)
Definition: StringMap.h:370
uint64_t
llvm::ELF::EI_CLASS
@ EI_CLASS
Definition: ELF.h:52
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::ELFYAML::ProgramHeader::Align
Optional< llvm::yaml::Hex64 > Align
Definition: ELFYAML.h:683
llvm::ELFYAML::SymtabShndxSection
Definition: ELFYAML.h:624
llvm::ELFYAML::ProgramHeader::FirstSec
Optional< StringRef > FirstSec
Definition: ELFYAML.h:687
llvm::DWARFYAML::getDWARFEmitterByName
std::function< Error(raw_ostream &, const Data &)> getDWARFEmitterByName(StringRef SecName)
Definition: DWARFEmitter.h:47
llvm::ELFYAML::RawContentSection::Info
Optional< llvm::yaml::Hex64 > Info
Definition: ELFYAML.h:361
llvm::ELF::SHF_STRINGS
@ SHF_STRINGS
Definition: ELF.h:1073
llvm::ELFYAML::ProgramHeader::Type
ELF_PT Type
Definition: ELFYAML.h:679
llvm::ELFYAML::BBAddrMapSection
Definition: ELFYAML.h:316
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
LEB128.h
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::ELFYAML::Object::Header
FileHeader Header
Definition: ELFYAML.h:695
llvm::ELF::EM_MIPS
@ EM_MIPS
Definition: ELF.h:141
llvm::ELFYAML::LinkerOptionsSection
Definition: ELFYAML.h:492
llvm::DenseMap
Definition: DenseMap.h:714
llvm::ELF::EV_CURRENT
@ EV_CURRENT
Definition: ELF.h:127
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::ELFYAML::StackSizesSection
Definition: ELFYAML.h:330
ArrayRef.h
llvm::ELFYAML::Symbol
Definition: ELFYAML.h:136
llvm::ELFYAML::Chunk::Name
StringRef Name
Definition: ELFYAML.h:213
llvm::ELFYAML::Section::Type
ELF_SHT Type
Definition: ELFYAML.h:225
llvm::ELF::SHF_ALLOC
@ SHF_ALLOC
Definition: ELF.h:1064
llvm::ELF::SHT_LLVM_BB_ADDR_MAP
@ SHT_LLVM_BB_ADDR_MAP
Definition: ELF.h:1017
llvm::ELFYAML::VernauxEntry::Other
uint16_t Other
Definition: ELFYAML.h:450
llvm::ELF::SHT_LLVM_CALL_GRAPH_PROFILE
@ SHT_LLVM_CALL_GRAPH_PROFILE
Definition: ELF.h:1016
llvm::ELFYAML::VernauxEntry::Flags
uint16_t Flags
Definition: ELFYAML.h:449
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
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::ELFYAML::BBAddrMapEntry
Definition: ELFYAML.h:158
overrideFields
static void overrideFields(ELFYAML::Section *From, typename ELFT::Shdr &To)
Definition: ELFEmitter.cpp:633
llvm::ELFYAML::MipsABIFlags
Definition: ELFYAML.h:658
Ptr
@ Ptr
Definition: TargetLibraryInfo.cpp:60
ELFTypes.h
isMips64EL
static bool isMips64EL(const ELFYAML::Object &Obj)
Definition: ELFEmitter.cpp:1259
llvm::ELFYAML::ARMIndexTableSection
Definition: ELFYAML.h:643
llvm::object::Elf_CGProfile_Impl
Definition: ELFTypes.h:46
zero
static void zero(T &Obj)
Definition: ELFEmitter.cpp:335
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::empty
bool empty() const
Definition: DenseMap.h:98
llvm::ELFYAML::Section::Link
Optional< StringRef > Link
Definition: ELFYAML.h:228
llvm::ELF::SHT_LLVM_ADDRSIG
@ SHT_LLVM_ADDRSIG
Definition: ELF.h:1006
llvm::StringTableBuilder::write
void write(raw_ostream &OS) const
Definition: StringTableBuilder.cpp:60
llvm::ELFYAML::DynamicSection
Definition: ELFYAML.h:348
llvm::ELFYAML::SectionHeaderTable::Excluded
Optional< std::vector< SectionHeader > > Excluded
Definition: ELFYAML.h:300
llvm::SetVector< T, SmallVector< T, N >, SmallDenseSet< T, N > >::insert
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
YAMLTraits.h
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1690
llvm::StringSet
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
yaml2obj.h
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::ELFYAML::Object::ProgramHeaders
std::vector< ProgramHeader > ProgramHeaders
Definition: ELFYAML.h:696
llvm::any_of
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1716
llvm::ELFYAML::FileHeader::Class
ELF_ELFCLASS Class
Definition: ELFYAML.h:113
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::ELF::ELFDATA2LSB
@ ELFDATA2LSB
Definition: ELF.h:335
llvm::yaml::BinaryRef
Specialized YAMLIO scalar type for representing a binary blob.
Definition: YAML.h:63
llvm::raw_svector_ostream::str
StringRef str() const
Return a StringRef for the vector contents.
Definition: raw_ostream.h:683
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::ELF::GRP_COMDAT
@ GRP_COMDAT
Definition: ELF.h:1164
llvm::ELFYAML::NoteEntry
Definition: ELFYAML.h:176
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
A
* A
Definition: README_ALTIVEC.txt:89
llvm::RoundingMode::Dynamic
@ Dynamic
Denotes mode unknown at compile time.
uint32_t
llvm::ELFYAML::ProgramHeader::PAddr
llvm::yaml::Hex64 PAddr
Definition: ELFYAML.h:682
llvm::ELF::EI_ABIVERSION
@ EI_ABIVERSION
Definition: ELF.h:56
llvm::ELFYAML::FileHeader::Data
ELF_ELFDATA Data
Definition: ELFYAML.h:114
emitDWARF
Expected< uint64_t > emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name, const DWARFYAML::Data &DWARF, ContiguousBlobAccumulator &CBA)
Definition: ELFEmitter.cpp:1073
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::ELFYAML::Relocation::Type
ELF_REL Type
Definition: ELFYAML.h:591
ELFObjectFile.h
LLVM_ELF_IMPORT_TYPES_ELFT
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
Definition: ELFTypes.h:104
llvm::find_if
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1736
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::ELFYAML::SectionHeaderTable
Definition: ELFYAML.h:291
DWARFEmitter.h
StringSet.h
llvm::ELF::EI_VERSION
@ EI_VERSION
Definition: ELF.h:54
WithColor.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1238
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
EndianStream.h
H
#define H(x, y, z)
Definition: MD5.cpp:57
llvm::ELFYAML::ARMIndexTableEntry
Definition: ELFYAML.h:638
llvm::None
constexpr std::nullopt_t None
Definition: None.h:27
llvm::ELF::SHT_GNU_verneed
@ SHT_GNU_verneed
Definition: ELF.h:1025
uint16_t
llvm::ELF::EI_MAG0
@ EI_MAG0
Definition: ELF.h:48
llvm::ELFYAML::VerneedEntry::Version
uint16_t Version
Definition: ELFYAML.h:455
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::ELFYAML::RelrSection
Definition: ELFYAML.h:610
llvm::ELFYAML::DynamicEntry::Val
llvm::yaml::Hex64 Val
Definition: ELFYAML.h:155
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
SuffixStart
constexpr char SuffixStart
Definition: ELFEmitter.cpp:684
llvm::ELFYAML::CallGraphEntryWeight
Definition: ELFYAML.h:521
llvm::sampleprof::SecType
SecType
Definition: SampleProf.h:121
llvm::SetVector::count
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:215
llvm::ELFYAML::Section::AddressAlign
llvm::yaml::Hex64 AddressAlign
Definition: ELFYAML.h:229
llvm::is_sorted
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition: STLExtras.h:1858
llvm::ELFYAML::VerneedEntry::AuxV
std::vector< VernauxEntry > AuxV
Definition: ELFYAML.h:457
llvm::ELFYAML::Section::Content
Optional< yaml::BinaryRef > Content
Definition: ELFYAML.h:232
llvm::StringTableBuilder
Utility for building string tables with deduplicated suffixes.
Definition: StringTableBuilder.h:23
llvm::StringMap< std::nullopt_t, MallocAllocator >::count
size_type count(StringRef Key) const
count - Return 1 if the element is in the map, 0 otherwise.
Definition: StringMap.h:245
llvm::ELFYAML::Relocation::Addend
YAMLIntUInt Addend
Definition: ELFYAML.h:590
llvm::ELF::ET_REL
@ ET_REL
Definition: ELF.h:116
writeArrayData
static void writeArrayData(raw_ostream &OS, ArrayRef< T > A)
Definition: ELFEmitter.cpp:331
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:475
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::ELFYAML::Section::Size
Optional< llvm::yaml::Hex64 > Size
Definition: ELFYAML.h:233
llvm::ELFYAML::ProgramHeader::Offset
Optional< llvm::yaml::Hex64 > Offset
Definition: ELFYAML.h:686
llvm::ELFYAML::BBAddrMapEntry::BBEntry::AddressOffset
llvm::yaml::Hex64 AddressOffset
Definition: ELFYAML.h:160
llvm::ELFYAML::ProgramHeader::FileSize
Optional< llvm::yaml::Hex64 > FileSize
Definition: ELFYAML.h:684
lookup
static bool lookup(const GsymReader &GR, DataExtractor &Data, uint64_t &Offset, uint64_t BaseAddr, uint64_t Addr, SourceLocations &SrcLocs, llvm::Error &Err)
A Lookup helper functions.
Definition: InlineInfo.cpp:108
llvm::ELFYAML::Section
Definition: ELFYAML.h:224
llvm::ELFYAML::DynamicEntry
Definition: ELFYAML.h:153
llvm::ELF::SHT_RELA
@ SHT_RELA
Definition: ELF.h:983
llvm::ELFYAML::VerdefSection
Definition: ELFYAML.h:560
llvm::ELFYAML::Object::getSectionHeaderTable
const SectionHeaderTable & getSectionHeaderTable() const
Definition: ELFYAML.h:718
N
#define N
llvm::StringTableBuilder::ELF
@ ELF
Definition: StringTableBuilder.h:26
llvm::ELFYAML::BBAddrMapEntry::BBEntry
Definition: ELFYAML.h:159
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
llvm::ELF::ELFCLASS64
@ ELFCLASS64
Definition: ELF.h:329
llvm::ELF::STB_LOCAL
@ STB_LOCAL
Definition: ELF.h:1217
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:658
llvm::encodeULEB128
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition: LEB128.h:80
llvm::ELFYAML::HashSection
Definition: ELFYAML.h:391
llvm::support::endianness
endianness
Definition: Endian.h:27
llvm::ELF::EI_MAG2
@ EI_MAG2
Definition: ELF.h:50
shouldEmitDWARF
static bool shouldEmitDWARF(DWARFYAML::Data &DWARF, StringRef Name)
Definition: ELFEmitter.cpp:1067
llvm::SmallSetVector
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:307
llvm::ELFYAML::VerneedSection
Definition: ELFYAML.h:460
llvm::ELF::SHT_NULL
@ SHT_NULL
Definition: ELF.h:979
llvm::ELFYAML::DependentLibrariesSection
Definition: ELFYAML.h:506
llvm::ELFYAML::BBAddrMapEntry::BBEntry::Metadata
llvm::yaml::Hex64 Metadata
Definition: ELFYAML.h:162
llvm::omp::RTLDependInfoFields::Flags
@ Flags
llvm::ELFYAML::ProgramHeader::MemSize
Optional< llvm::yaml::Hex64 > MemSize
Definition: ELFYAML.h:685
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::ELF::ELFCLASS32
@ ELFCLASS32
Definition: ELF.h:328
llvm::ELFYAML::ProgramHeader::VAddr
llvm::yaml::Hex64 VAddr
Definition: ELFYAML.h:681
raw_ostream.h
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
copy
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same we currently get code like const It could be done with a smaller encoding like local tee $pop5 local copy
Definition: README.txt:101
getDefaultLinkSec
static StringRef getDefaultLinkSec(unsigned SecType)
Definition: ELFEmitter.cpp:733
llvm::StringRef::copy
StringRef copy(Allocator &A) const
Definition: StringRef.h:153
llvm::ELFYAML::StackSizeEntry
Definition: ELFYAML.h:171
llvm::Optional::value_or
constexpr T value_or(U &&alt) const &
Definition: Optional.h:291
llvm::ELF::SHT_REL
@ SHT_REL
Definition: ELF.h:988
llvm::handleAllErrors
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:965
llvm::ELF::SHT_DYNAMIC
@ SHT_DYNAMIC
Definition: ELF.h:985
llvm::ELF::EI_MAG3
@ EI_MAG3
Definition: ELF.h:51
llvm::ELFYAML::VernauxEntry
Definition: ELFYAML.h:447
SetVector.h
llvm::ELFYAML::ProgramHeader::Flags
ELF_PF Flags
Definition: ELFYAML.h:680
llvm::ELFYAML::Chunk
Definition: ELFYAML.h:182
Shdr
Elf_Shdr Shdr
Definition: ELFObjHandler.cpp:77
llvm::ELFYAML::Chunk::IsImplicit
bool IsImplicit
Definition: ELFYAML.h:218