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