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