llvm/lib/ObjectYAML/ELFEmitter.cpp

   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
  35 using namespace llvm;
  36
  37 // This class is used to build up a contiguous binary blob while keeping
  38 // track of an offset in the output (which notionally begins at
  39 // `InitialOffset`).
  40 // The blob might be limited to an arbitrary size. All attempts to write data
  41 // are ignored and the error condition is remembered once the limit is reached.
  42 // Such an approach allows us to simplify the code by delaying error reporting
  43 // and doing it at a convenient time.
  44 namespace {
  45 class ContiguousBlobAccumulator {
  46   const uint64_t InitialOffset;
  47   const uint64_t MaxSize;
  48
  49   SmallVector<char, 128> Buf;
  50   raw_svector_ostream OS;
  51   Error ReachedLimitErr = Error::success();
  52
  53   bool checkLimit(uint64_t Size) {
  54     if (!ReachedLimitErr && getOffset() + Size <= MaxSize)
  55       return true;
  56     if (!ReachedLimitErr)
  57       ReachedLimitErr = createStringError(errc::invalid_argument,
  58                                           "reached the output size limit");
  59     return false;
  60   }
  61
  62 public:
  63   ContiguousBlobAccumulator(uint64_t BaseOffset, uint64_t SizeLimit)
  64       : InitialOffset(BaseOffset), MaxSize(SizeLimit), OS(Buf) {}
  65
  66   uint64_t tell() const { return OS.tell(); }
  67   uint64_t getOffset() const { return InitialOffset + OS.tell(); }
  68   void writeBlobToStream(raw_ostream &Out) const { Out << OS.str(); }
  69
  70   Error takeLimitError() {
  71     // Request to write 0 bytes to check we did not reach the limit.
  72     checkLimit(0);
  73     return std::move(ReachedLimitErr);
  74   }
  75
  76   /// \returns The new offset.
  77   uint64_t padToAlignment(unsigned Align) {
  78     uint64_t CurrentOffset = getOffset();
  79     if (ReachedLimitErr)
  80       return CurrentOffset;
  81
  82     uint64_t AlignedOffset = alignTo(CurrentOffset, Align == 0 ? 1 : Align);
  83     uint64_t PaddingSize = AlignedOffset - CurrentOffset;
  84     if (!checkLimit(PaddingSize))
  85       return CurrentOffset;
  86
  87     writeZeros(PaddingSize);
  88     return AlignedOffset;
  89   }
  90
  91   raw_ostream *getRawOS(uint64_t Size) {
  92     if (checkLimit(Size))
  93       return &OS;
  94     return nullptr;
  95   }
  96
  97   void writeAsBinary(const yaml::BinaryRef &Bin, uint64_t N = UINT64_MAX) {
  98     if (!checkLimit(Bin.binary_size()))
  99       return;
 100     Bin.writeAsBinary(OS, N);
 101   }
 102
 103   void writeZeros(uint64_t Num) {
 104     if (checkLimit(Num))
 105       OS.write_zeros(Num);
 106   }
 107
 108   void write(const char *Ptr, size_t Size) {
 109     if (checkLimit(Size))
 110       OS.write(Ptr, Size);
 111   }
 112
 113   void write(unsigned char C) {
 114     if (checkLimit(1))
 115       OS.write(C);
 116   }
 117
 118   unsigned writeULEB128(uint64_t Val) {
 119     if (!checkLimit(sizeof(uint64_t)))
 120       return 0;
 121     return encodeULEB128(Val, OS);
 122   }
 123
 124   template <typename T> void write(T Val, support::endianness E) {
 125     if (checkLimit(sizeof(T)))
 126       support::endian::write<T>(OS, Val, E);
 127   }
 128
 129   void updateDataAt(uint64_t Pos, void *Data, size_t Size) {
 130     assert(Pos >= InitialOffset && Pos + Size <= getOffset());
 131     memcpy(&Buf[Pos - InitialOffset], Data, Size);
 132   }
 133 };
 134
 135 // Used to keep track of section and symbol names, so that in the YAML file
 136 // sections and symbols can be referenced by name instead of by index.
 137 class NameToIdxMap {
 138   StringMap<unsigned> Map;
 139
 140 public:
 141   /// \Returns false if name is already present in the map.
 142   bool addName(StringRef Name, unsigned Ndx) {
 143     return Map.insert({Name, Ndx}).second;
 144   }
 145   /// \Returns false if name is not present in the map.
 146   bool lookup(StringRef Name, unsigned &Idx) const {
 147     auto I = Map.find(Name);
 148     if (I == Map.end())
 149       return false;
 150     Idx = I->getValue();
 151     return true;
 152   }
 153   /// Asserts if name is not present in the map.
 154   unsigned get(StringRef Name) const {
 155     unsigned Idx;
 156     if (lookup(Name, Idx))
 157       return Idx;
 158     assert(false && "Expected section not found in index");
 159     return 0;
 160   }
 161   unsigned size() const { return Map.size(); }
 162 };
 163
 164 namespace {
 165 struct Fragment {
 166   uint64_t Offset;
 167   uint64_t Size;
 168   uint32_t Type;
 169   uint64_t AddrAlign;
 170 };
 171 } // namespace
 172
 173 /// "Single point of truth" for the ELF file construction.
 174 /// TODO: This class still has a ways to go before it is truly a "single
 175 /// point of truth".
 176 template <class ELFT> class ELFState {
 177   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
 178
 179   enum class SymtabType { Static, Dynamic };
 180
 181   /// The future symbol table string section.
 182   StringTableBuilder DotStrtab{StringTableBuilder::ELF};
 183
 184   /// The future section header string table section, if a unique string table
 185   /// is needed. Don't reference this variable direectly: use the
 186   /// ShStrtabStrings member instead.
 187   StringTableBuilder DotShStrtab{StringTableBuilder::ELF};
 188
 189   /// The future dynamic symbol string section.
 190   StringTableBuilder DotDynstr{StringTableBuilder::ELF};
 191
 192   /// The name of the section header string table section. If it is .strtab or
 193   /// .dynstr, the section header strings will be written to the same string
 194   /// table as the static/dynamic symbols respectively. Otherwise a dedicated
 195   /// section will be created with that name.
 196   StringRef SectionHeaderStringTableName = ".shstrtab";
 197   StringTableBuilder *ShStrtabStrings = &DotShStrtab;
 198
 199   NameToIdxMap SN2I;
 200   NameToIdxMap SymN2I;
 201   NameToIdxMap DynSymN2I;
 202   ELFYAML::Object &Doc;
 203
 204   StringSet<> ExcludedSectionHeaders;
 205
 206   uint64_t LocationCounter = 0;
 207   bool HasError = false;
 208   yaml::ErrorHandler ErrHandler;
 209   void reportError(const Twine &Msg);
 210   void reportError(Error Err);
 211
 212   std::vector<Elf_Sym> toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
 213                                     const StringTableBuilder &Strtab);
 214   unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
 215   unsigned toSymbolIndex(StringRef S, StringRef LocSec, bool IsDynamic);
 216
 217   void buildSectionIndex();
 218   void buildSymbolIndexes();
 219   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
 220   bool initImplicitHeader(ContiguousBlobAccumulator &CBA, Elf_Shdr &Header,
 221                           StringRef SecName, ELFYAML::Section *YAMLSec);
 222   void initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
 223                           ContiguousBlobAccumulator &CBA);
 224   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
 225                                ContiguousBlobAccumulator &CBA,
 226                                ELFYAML::Section *YAMLSec);
 227   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
 228                                StringTableBuilder &STB,
 229                                ContiguousBlobAccumulator &CBA,
 230                                ELFYAML::Section *YAMLSec);
 231   void initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
 232                               ContiguousBlobAccumulator &CBA,
 233                               ELFYAML::Section *YAMLSec);
 234   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
 235                               std::vector<Elf_Shdr> &SHeaders);
 236
 237   std::vector<Fragment>
 238   getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
 239                    ArrayRef<typename ELFT::Shdr> SHeaders);
 240
 241   void finalizeStrings();
 242   void writeELFHeader(raw_ostream &OS);
 243   void writeSectionContent(Elf_Shdr &SHeader,
 244                            const ELFYAML::NoBitsSection &Section,
 245                            ContiguousBlobAccumulator &CBA);
 246   void writeSectionContent(Elf_Shdr &SHeader,
 247                            const ELFYAML::RawContentSection &Section,
 248                            ContiguousBlobAccumulator &CBA);
 249   void writeSectionContent(Elf_Shdr &SHeader,
 250                            const ELFYAML::RelocationSection &Section,
 251                            ContiguousBlobAccumulator &CBA);
 252   void writeSectionContent(Elf_Shdr &SHeader,
 253                            const ELFYAML::RelrSection &Section,
 254                            ContiguousBlobAccumulator &CBA);
 255   void writeSectionContent(Elf_Shdr &SHeader,
 256                            const ELFYAML::GroupSection &Group,
 257                            ContiguousBlobAccumulator &CBA);
 258   void writeSectionContent(Elf_Shdr &SHeader,
 259                            const ELFYAML::SymtabShndxSection &Shndx,
 260                            ContiguousBlobAccumulator &CBA);
 261   void writeSectionContent(Elf_Shdr &SHeader,
 262                            const ELFYAML::SymverSection &Section,
 263                            ContiguousBlobAccumulator &CBA);
 264   void writeSectionContent(Elf_Shdr &SHeader,
 265                            const ELFYAML::VerneedSection &Section,
 266                            ContiguousBlobAccumulator &CBA);
 267   void writeSectionContent(Elf_Shdr &SHeader,
 268                            const ELFYAML::VerdefSection &Section,
 269                            ContiguousBlobAccumulator &CBA);
 270   void writeSectionContent(Elf_Shdr &SHeader,
 271                            const ELFYAML::ARMIndexTableSection &Section,
 272                            ContiguousBlobAccumulator &CBA);
 273   void writeSectionContent(Elf_Shdr &SHeader,
 274                            const ELFYAML::MipsABIFlags &Section,
 275                            ContiguousBlobAccumulator &CBA);
 276   void writeSectionContent(Elf_Shdr &SHeader,
 277                            const ELFYAML::DynamicSection &Section,
 278                            ContiguousBlobAccumulator &CBA);
 279   void writeSectionContent(Elf_Shdr &SHeader,
 280                            const ELFYAML::StackSizesSection &Section,
 281                            ContiguousBlobAccumulator &CBA);
 282   void writeSectionContent(Elf_Shdr &SHeader,
 283                            const ELFYAML::BBAddrMapSection &Section,
 284                            ContiguousBlobAccumulator &CBA);
 285   void writeSectionContent(Elf_Shdr &SHeader,
 286                            const ELFYAML::HashSection &Section,
 287                            ContiguousBlobAccumulator &CBA);
 288   void writeSectionContent(Elf_Shdr &SHeader,
 289                            const ELFYAML::AddrsigSection &Section,
 290                            ContiguousBlobAccumulator &CBA);
 291   void writeSectionContent(Elf_Shdr &SHeader,
 292                            const ELFYAML::NoteSection &Section,
 293                            ContiguousBlobAccumulator &CBA);
 294   void writeSectionContent(Elf_Shdr &SHeader,
 295                            const ELFYAML::GnuHashSection &Section,
 296                            ContiguousBlobAccumulator &CBA);
 297   void writeSectionContent(Elf_Shdr &SHeader,
 298                            const ELFYAML::LinkerOptionsSection &Section,
 299                            ContiguousBlobAccumulator &CBA);
 300   void writeSectionContent(Elf_Shdr &SHeader,
 301                            const ELFYAML::DependentLibrariesSection &Section,
 302                            ContiguousBlobAccumulator &CBA);
 303   void writeSectionContent(Elf_Shdr &SHeader,
 304                            const ELFYAML::CallGraphProfileSection &Section,
 305                            ContiguousBlobAccumulator &CBA);
 306
 307   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 308
 309   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 310
 311   void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
 312
 313   DenseMap<StringRef, size_t> buildSectionHeaderReorderMap();
 314
 315   BumpPtrAllocator StringAlloc;
 316   uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
 317                          llvm::Optional<llvm::yaml::Hex64> Offset);
 318
 319   uint64_t getSectionNameOffset(StringRef Name);
 320
 321 public:
 322   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
 323                        yaml::ErrorHandler EH, uint64_t MaxSize);
 324 };
 325 } // end anonymous namespace
 326
 327 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
 328   return A.size() * sizeof(T);
 329 }
 330
 331 template <class T> static void writeArrayData(raw_ostream &OS, ArrayRef<T> A) {
 332   OS.write((const char *)A.data(), arrayDataSize(A));
 333 }
 334
 335 template <class T> static void zero(T &Obj) { memset(&Obj, 0, sizeof(Obj)); }
 336
 337 template <class ELFT>
 338 ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
 339     : Doc(D), ErrHandler(EH) {
 340   // The input may explicitly request to store the section header table strings
 341   // in the same string table as dynamic or static symbol names. Set the
 342   // ShStrtabStrings member accordingly.
 343   if (Doc.Header.SectionHeaderStringTable) {
 344     SectionHeaderStringTableName = *Doc.Header.SectionHeaderStringTable;
 345     if (*Doc.Header.SectionHeaderStringTable == ".strtab")
 346       ShStrtabStrings = &DotStrtab;
 347     else if (*Doc.Header.SectionHeaderStringTable == ".dynstr")
 348       ShStrtabStrings = &DotDynstr;
 349     // Otherwise, the unique table will be used.
 350   }
 351
 352   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
 353   // Insert SHT_NULL section implicitly when it is not defined in YAML.
 354   if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
 355     Doc.Chunks.insert(
 356         Doc.Chunks.begin(),
 357         std::make_unique<ELFYAML::Section>(
 358             ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
 359
 360   StringSet<> DocSections;
 361   ELFYAML::SectionHeaderTable *SecHdrTable = nullptr;
 362   for (size_t I = 0; I < Doc.Chunks.size(); ++I) {
 363     const std::unique_ptr<ELFYAML::Chunk> &C = Doc.Chunks[I];
 364
 365     // We might have an explicit section header table declaration.
 366     if (auto S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
 367       if (SecHdrTable)
 368         reportError("multiple section header tables are not allowed");
 369       SecHdrTable = S;
 370       continue;
 371     }
 372
 373     // We add a technical suffix for each unnamed section/fill. It does not
 374     // affect the output, but allows us to map them by name in the code and
 375     // report better error messages.
 376     if (C->Name.empty()) {
 377       std::string NewName = ELFYAML::appendUniqueSuffix(
 378           /*Name=*/"", "index " + Twine(I));
 379       C->Name = StringRef(NewName).copy(StringAlloc);
 380       assert(ELFYAML::dropUniqueSuffix(C->Name).empty());
 381     }
 382
 383     if (!DocSections.insert(C->Name).second)
 384       reportError("repeated section/fill name: '" + C->Name +
 385                   "' at YAML section/fill number " + Twine(I));
 386   }
 387
 388   SmallSetVector<StringRef, 8> ImplicitSections;
 389   if (Doc.DynamicSymbols) {
 390     if (SectionHeaderStringTableName == ".dynsym")
 391       reportError("cannot use '.dynsym' as the section header name table when "
 392                   "there are dynamic symbols");
 393     ImplicitSections.insert(".dynsym");
 394     ImplicitSections.insert(".dynstr");
 395   }
 396   if (Doc.Symbols) {
 397     if (SectionHeaderStringTableName == ".symtab")
 398       reportError("cannot use '.symtab' as the section header name table when "
 399                   "there are symbols");
 400     ImplicitSections.insert(".symtab");
 401   }
 402   if (Doc.DWARF)
 403     for (StringRef DebugSecName : Doc.DWARF->getNonEmptySectionNames()) {
 404       std::string SecName = ("." + DebugSecName).str();
 405       // TODO: For .debug_str it should be possible to share the string table,
 406       // in the same manner as the symbol string tables.
 407       if (SectionHeaderStringTableName == SecName)
 408         reportError("cannot use '" + SecName +
 409                     "' as the section header name table when it is needed for "
 410                     "DWARF output");
 411       ImplicitSections.insert(StringRef(SecName).copy(StringAlloc));
 412     }
 413   // TODO: Only create the .strtab here if any symbols have been requested.
 414   ImplicitSections.insert(".strtab");
 415   if (!SecHdrTable || !SecHdrTable->NoHeaders.getValueOr(false))
 416     ImplicitSections.insert(SectionHeaderStringTableName);
 417
 418   // Insert placeholders for implicit sections that are not
 419   // defined explicitly in YAML.
 420   for (StringRef SecName : ImplicitSections) {
 421     if (DocSections.count(SecName))
 422       continue;
 423
 424     std::unique_ptr<ELFYAML::Section> Sec = std::make_unique<ELFYAML::Section>(
 425         ELFYAML::Chunk::ChunkKind::RawContent, true /*IsImplicit*/);
 426     Sec->Name = SecName;
 427
 428     if (SecName == SectionHeaderStringTableName)
 429       Sec->Type = ELF::SHT_STRTAB;
 430     else if (SecName == ".dynsym")
 431       Sec->Type = ELF::SHT_DYNSYM;
 432     else if (SecName == ".symtab")
 433       Sec->Type = ELF::SHT_SYMTAB;
 434     else
 435       Sec->Type = ELF::SHT_STRTAB;
 436
 437     // When the section header table is explicitly defined at the end of the
 438     // sections list, it is reasonable to assume that the user wants to reorder
 439     // section headers, but still wants to place the section header table after
 440     // all sections, like it normally happens. In this case we want to insert
 441     // other implicit sections right before the section header table.
 442     if (Doc.Chunks.back().get() == SecHdrTable)
 443       Doc.Chunks.insert(Doc.Chunks.end() - 1, std::move(Sec));
 444     else
 445       Doc.Chunks.push_back(std::move(Sec));
 446   }
 447
 448   // Insert the section header table implicitly at the end, when it is not
 449   // explicitly defined.
 450   if (!SecHdrTable)
 451     Doc.Chunks.push_back(
 452         std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/true));
 453 }
 454
 455 template <class ELFT>
 456 void ELFState<ELFT>::writeELFHeader(raw_ostream &OS) {
 457   using namespace llvm::ELF;
 458
 459   Elf_Ehdr Header;
 460   zero(Header);
 461   Header.e_ident[EI_MAG0] = 0x7f;
 462   Header.e_ident[EI_MAG1] = 'E';
 463   Header.e_ident[EI_MAG2] = 'L';
 464   Header.e_ident[EI_MAG3] = 'F';
 465   Header.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
 466   Header.e_ident[EI_DATA] = Doc.Header.Data;
 467   Header.e_ident[EI_VERSION] = EV_CURRENT;
 468   Header.e_ident[EI_OSABI] = Doc.Header.OSABI;
 469   Header.e_ident[EI_ABIVERSION] = Doc.Header.ABIVersion;
 470   Header.e_type = Doc.Header.Type;
 471
 472   if (Doc.Header.Machine)
 473     Header.e_machine = *Doc.Header.Machine;
 474   else
 475     Header.e_machine = EM_NONE;
 476
 477   Header.e_version = EV_CURRENT;
 478   Header.e_entry = Doc.Header.Entry;
 479   Header.e_flags = Doc.Header.Flags;
 480   Header.e_ehsize = sizeof(Elf_Ehdr);
 481
 482   if (Doc.Header.EPhOff)
 483     Header.e_phoff = *Doc.Header.EPhOff;
 484   else if (!Doc.ProgramHeaders.empty())
 485     Header.e_phoff = sizeof(Header);
 486   else
 487     Header.e_phoff = 0;
 488
 489   if (Doc.Header.EPhEntSize)
 490     Header.e_phentsize = *Doc.Header.EPhEntSize;
 491   else if (!Doc.ProgramHeaders.empty())
 492     Header.e_phentsize = sizeof(Elf_Phdr);
 493   else
 494     Header.e_phentsize = 0;
 495
 496   if (Doc.Header.EPhNum)
 497     Header.e_phnum = *Doc.Header.EPhNum;
 498   else if (!Doc.ProgramHeaders.empty())
 499     Header.e_phnum = Doc.ProgramHeaders.size();
 500   else
 501     Header.e_phnum = 0;
 502
 503   Header.e_shentsize = Doc.Header.EShEntSize ? (uint16_t)*Doc.Header.EShEntSize
 504                                              : sizeof(Elf_Shdr);
 505
 506   const ELFYAML::SectionHeaderTable &SectionHeaders =
 507       Doc.getSectionHeaderTable();
 508
 509   if (Doc.Header.EShOff)
 510     Header.e_shoff = *Doc.Header.EShOff;
 511   else if (SectionHeaders.Offset)
 512     Header.e_shoff = *SectionHeaders.Offset;
 513   else
 514     Header.e_shoff = 0;
 515
 516   if (Doc.Header.EShNum)
 517     Header.e_shnum = *Doc.Header.EShNum;
 518   else
 519     Header.e_shnum = SectionHeaders.getNumHeaders(Doc.getSections().size());
 520
 521   if (Doc.Header.EShStrNdx)
 522     Header.e_shstrndx = *Doc.Header.EShStrNdx;
 523   else if (SectionHeaders.Offset &&
 524            !ExcludedSectionHeaders.count(SectionHeaderStringTableName))
 525     Header.e_shstrndx = SN2I.get(SectionHeaderStringTableName);
 526   else
 527     Header.e_shstrndx = 0;
 528
 529   OS.write((const char *)&Header, sizeof(Header));
 530 }
 531
 532 template <class ELFT>
 533 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
 534   DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
 535   DenseMap<StringRef, size_t> NameToIndex;
 536   for (size_t I = 0, E = Doc.Chunks.size(); I != E; ++I) {
 537     if (auto S = dyn_cast<ELFYAML::Fill>(Doc.Chunks[I].get()))
 538       NameToFill[S->Name] = S;
 539     NameToIndex[Doc.Chunks[I]->Name] = I + 1;
 540   }
 541
 542   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
 543   for (size_t I = 0, E = Doc.ProgramHeaders.size(); I != E; ++I) {
 544     ELFYAML::ProgramHeader &YamlPhdr = Doc.ProgramHeaders[I];
 545     Elf_Phdr Phdr;
 546     zero(Phdr);
 547     Phdr.p_type = YamlPhdr.Type;
 548     Phdr.p_flags = YamlPhdr.Flags;
 549     Phdr.p_vaddr = YamlPhdr.VAddr;
 550     Phdr.p_paddr = YamlPhdr.PAddr;
 551     PHeaders.push_back(Phdr);
 552
 553     if (!YamlPhdr.FirstSec && !YamlPhdr.LastSec)
 554       continue;
 555
 556     // Get the index of the section, or 0 in the case when the section doesn't exist.
 557     size_t First = NameToIndex[*YamlPhdr.FirstSec];
 558     if (!First)
 559       reportError("unknown section or fill referenced: '" + *YamlPhdr.FirstSec +
 560                   "' by the 'FirstSec' key of the program header with index " +
 561                   Twine(I));
 562     size_t Last = NameToIndex[*YamlPhdr.LastSec];
 563     if (!Last)
 564       reportError("unknown section or fill referenced: '" + *YamlPhdr.LastSec +
 565                   "' by the 'LastSec' key of the program header with index " +
 566                   Twine(I));
 567     if (!First || !Last)
 568       continue;
 569
 570     if (First > Last)
 571       reportError("program header with index " + Twine(I) +
 572                   ": the section index of " + *YamlPhdr.FirstSec +
 573                   " is greater than the index of " + *YamlPhdr.LastSec);
 574
 575     for (size_t I = First; I <= Last; ++I)
 576       YamlPhdr.Chunks.push_back(Doc.Chunks[I - 1].get());
 577   }
 578 }
 579
 580 template <class ELFT>
 581 unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
 582                                         StringRef LocSym) {
 583   assert(LocSec.empty() || LocSym.empty());
 584
 585   unsigned Index;
 586   if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) {
 587     if (!LocSym.empty())
 588       reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
 589                   LocSym + "'");
 590     else
 591       reportError("unknown section referenced: '" + S + "' by YAML section '" +
 592                   LocSec + "'");
 593     return 0;
 594   }
 595
 596   const ELFYAML::SectionHeaderTable &SectionHeaders =
 597       Doc.getSectionHeaderTable();
 598   if (SectionHeaders.IsImplicit ||
 599       (SectionHeaders.NoHeaders && !SectionHeaders.NoHeaders.getValue()) ||
 600       SectionHeaders.isDefault())
 601     return Index;
 602
 603   assert(!SectionHeaders.NoHeaders.getValueOr(false) ||
 604          !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 Optional<yaml::BinaryRef> &Content,
 720                              const 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.getValueOr(false))
 775         continue;
 776
 777       if (!S->Offset)
 778         S->Offset = alignToOffset(CBA, sizeof(typename ELFT::uint),
 779                                   /*Offset=*/None);
 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.getValueOr(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.getValueOr(yaml::Hex64(0));
 962     Symbol.st_other = Sym.Other ? *Sym.Other : 0;
 963     Symbol.st_size = Sym.Size.getValueOr(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 =
1020       alignToOffset(CBA, SHeader.sh_addralign, RawSec ? RawSec->Offset : None);
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 : None);
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 : None);
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   if (!Section.Entries)
1384     return;
1385
1386   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
1387     CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
1388     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.Size);
1389   }
1390 }
1391
1392 template <class ELFT>
1393 void ELFState<ELFT>::writeSectionContent(
1394     Elf_Shdr &SHeader, const ELFYAML::BBAddrMapSection &Section,
1395     ContiguousBlobAccumulator &CBA) {
1396   if (!Section.Entries)
1397     return;
1398
1399   for (const ELFYAML::BBAddrMapEntry &E : *Section.Entries) {
1400     // Write the address of the function.
1401     CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
1402     // Write number of BBEntries (number of basic blocks in the function). This
1403     // is overridden by the 'NumBlocks' YAML field when specified.
1404     uint64_t NumBlocks =
1405         E.NumBlocks.getValueOr(E.BBEntries ? E.BBEntries->size() : 0);
1406     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(NumBlocks);
1407     // Write all BBEntries.
1408     if (!E.BBEntries)
1409       continue;
1410     for (const ELFYAML::BBAddrMapEntry::BBEntry &BBE : *E.BBEntries)
1411       SHeader.sh_size += CBA.writeULEB128(BBE.AddressOffset) +
1412                          CBA.writeULEB128(BBE.Size) +
1413                          CBA.writeULEB128(BBE.Metadata);
1414   }
1415 }
1416
1417 template <class ELFT>
1418 void ELFState<ELFT>::writeSectionContent(
1419     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
1420     ContiguousBlobAccumulator &CBA) {
1421   if (!Section.Options)
1422     return;
1423
1424   for (const ELFYAML::LinkerOption &LO : *Section.Options) {
1425     CBA.write(LO.Key.data(), LO.Key.size());
1426     CBA.write('\0');
1427     CBA.write(LO.Value.data(), LO.Value.size());
1428     CBA.write('\0');
1429     SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
1430   }
1431 }
1432
1433 template <class ELFT>
1434 void ELFState<ELFT>::writeSectionContent(
1435     Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
1436     ContiguousBlobAccumulator &CBA) {
1437   if (!Section.Libs)
1438     return;
1439
1440   for (StringRef Lib : *Section.Libs) {
1441     CBA.write(Lib.data(), Lib.size());
1442     CBA.write('\0');
1443     SHeader.sh_size += Lib.size() + 1;
1444   }
1445 }
1446
1447 template <class ELFT>
1448 uint64_t
1449 ELFState<ELFT>::alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
1450                               llvm::Optional<llvm::yaml::Hex64> Offset) {
1451   uint64_t CurrentOffset = CBA.getOffset();
1452   uint64_t AlignedOffset;
1453
1454   if (Offset) {
1455     if ((uint64_t)*Offset < CurrentOffset) {
1456       reportError("the 'Offset' value (0x" +
1457                   Twine::utohexstr((uint64_t)*Offset) + ") goes backward");
1458       return CurrentOffset;
1459     }
1460
1461     // We ignore an alignment when an explicit offset has been requested.
1462     AlignedOffset = *Offset;
1463   } else {
1464     AlignedOffset = alignTo(CurrentOffset, std::max(Align, (uint64_t)1));
1465   }
1466
1467   CBA.writeZeros(AlignedOffset - CurrentOffset);
1468   return AlignedOffset;
1469 }
1470
1471 template <class ELFT>
1472 void ELFState<ELFT>::writeSectionContent(
1473     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
1474     ContiguousBlobAccumulator &CBA) {
1475   if (!Section.Entries)
1476     return;
1477
1478   for (const ELFYAML::CallGraphEntryWeight &E : *Section.Entries) {
1479     CBA.write<uint64_t>(E.Weight, ELFT::TargetEndianness);
1480     SHeader.sh_size += sizeof(object::Elf_CGProfile_Impl<ELFT>);
1481   }
1482 }
1483
1484 template <class ELFT>
1485 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1486                                          const ELFYAML::HashSection &Section,
1487                                          ContiguousBlobAccumulator &CBA) {
1488   if (!Section.Bucket)
1489     return;
1490
1491   if (!Section.Bucket)
1492     return;
1493
1494   CBA.write<uint32_t>(
1495       Section.NBucket.getValueOr(llvm::yaml::Hex64(Section.Bucket->size())),
1496       ELFT::TargetEndianness);
1497   CBA.write<uint32_t>(
1498       Section.NChain.getValueOr(llvm::yaml::Hex64(Section.Chain->size())),
1499       ELFT::TargetEndianness);
1500
1501   for (uint32_t Val : *Section.Bucket)
1502     CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1503   for (uint32_t Val : *Section.Chain)
1504     CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1505
1506   SHeader.sh_size = (2 + Section.Bucket->size() + Section.Chain->size()) * 4;
1507 }
1508
1509 template <class ELFT>
1510 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1511                                          const ELFYAML::VerdefSection &Section,
1512                                          ContiguousBlobAccumulator &CBA) {
1513
1514   if (Section.Info)
1515     SHeader.sh_info = *Section.Info;
1516   else if (Section.Entries)
1517     SHeader.sh_info = Section.Entries->size();
1518
1519   if (!Section.Entries)
1520     return;
1521
1522   uint64_t AuxCnt = 0;
1523   for (size_t I = 0; I < Section.Entries->size(); ++I) {
1524     const ELFYAML::VerdefEntry &E = (*Section.Entries)[I];
1525
1526     Elf_Verdef VerDef;
1527     VerDef.vd_version = E.Version.getValueOr(1);
1528     VerDef.vd_flags = E.Flags.getValueOr(0);
1529     VerDef.vd_ndx = E.VersionNdx.getValueOr(0);
1530     VerDef.vd_hash = E.Hash.getValueOr(0);
1531     VerDef.vd_aux = sizeof(Elf_Verdef);
1532     VerDef.vd_cnt = E.VerNames.size();
1533     if (I == Section.Entries->size() - 1)
1534       VerDef.vd_next = 0;
1535     else
1536       VerDef.vd_next =
1537           sizeof(Elf_Verdef) + E.VerNames.size() * sizeof(Elf_Verdaux);
1538     CBA.write((const char *)&VerDef, sizeof(Elf_Verdef));
1539
1540     for (size_t J = 0; J < E.VerNames.size(); ++J, ++AuxCnt) {
1541       Elf_Verdaux VernAux;
1542       VernAux.vda_name = DotDynstr.getOffset(E.VerNames[J]);
1543       if (J == E.VerNames.size() - 1)
1544         VernAux.vda_next = 0;
1545       else
1546         VernAux.vda_next = sizeof(Elf_Verdaux);
1547       CBA.write((const char *)&VernAux, sizeof(Elf_Verdaux));
1548     }
1549   }
1550
1551   SHeader.sh_size = Section.Entries->size() * sizeof(Elf_Verdef) +
1552                     AuxCnt * sizeof(Elf_Verdaux);
1553 }
1554
1555 template <class ELFT>
1556 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1557                                          const ELFYAML::VerneedSection &Section,
1558                                          ContiguousBlobAccumulator &CBA) {
1559   if (Section.Info)
1560     SHeader.sh_info = *Section.Info;
1561   else if (Section.VerneedV)
1562     SHeader.sh_info = Section.VerneedV->size();
1563
1564   if (!Section.VerneedV)
1565     return;
1566
1567   uint64_t AuxCnt = 0;
1568   for (size_t I = 0; I < Section.VerneedV->size(); ++I) {
1569     const ELFYAML::VerneedEntry &VE = (*Section.VerneedV)[I];
1570
1571     Elf_Verneed VerNeed;
1572     VerNeed.vn_version = VE.Version;
1573     VerNeed.vn_file = DotDynstr.getOffset(VE.File);
1574     if (I == Section.VerneedV->size() - 1)
1575       VerNeed.vn_next = 0;
1576     else
1577       VerNeed.vn_next =
1578           sizeof(Elf_Verneed) + VE.AuxV.size() * sizeof(Elf_Vernaux);
1579     VerNeed.vn_cnt = VE.AuxV.size();
1580     VerNeed.vn_aux = sizeof(Elf_Verneed);
1581     CBA.write((const char *)&VerNeed, sizeof(Elf_Verneed));
1582
1583     for (size_t J = 0; J < VE.AuxV.size(); ++J, ++AuxCnt) {
1584       const ELFYAML::VernauxEntry &VAuxE = VE.AuxV[J];
1585
1586       Elf_Vernaux VernAux;
1587       VernAux.vna_hash = VAuxE.Hash;
1588       VernAux.vna_flags = VAuxE.Flags;
1589       VernAux.vna_other = VAuxE.Other;
1590       VernAux.vna_name = DotDynstr.getOffset(VAuxE.Name);
1591       if (J == VE.AuxV.size() - 1)
1592         VernAux.vna_next = 0;
1593       else
1594         VernAux.vna_next = sizeof(Elf_Vernaux);
1595       CBA.write((const char *)&VernAux, sizeof(Elf_Vernaux));
1596     }
1597   }
1598
1599   SHeader.sh_size = Section.VerneedV->size() * sizeof(Elf_Verneed) +
1600                     AuxCnt * sizeof(Elf_Vernaux);
1601 }
1602
1603 template <class ELFT>
1604 void ELFState<ELFT>::writeSectionContent(
1605     Elf_Shdr &SHeader, const ELFYAML::ARMIndexTableSection &Section,
1606     ContiguousBlobAccumulator &CBA) {
1607   if (!Section.Entries)
1608     return;
1609
1610   for (const ELFYAML::ARMIndexTableEntry &E : *Section.Entries) {
1611     CBA.write<uint32_t>(E.Offset, ELFT::TargetEndianness);
1612     CBA.write<uint32_t>(E.Value, ELFT::TargetEndianness);
1613   }
1614   SHeader.sh_size = Section.Entries->size() * 8;
1615 }
1616
1617 template <class ELFT>
1618 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1619                                          const ELFYAML::MipsABIFlags &Section,
1620                                          ContiguousBlobAccumulator &CBA) {
1621   assert(Section.Type == llvm::ELF::SHT_MIPS_ABIFLAGS &&
1622          "Section type is not SHT_MIPS_ABIFLAGS");
1623
1624   object::Elf_Mips_ABIFlags<ELFT> Flags;
1625   zero(Flags);
1626   SHeader.sh_size = SHeader.sh_entsize;
1627
1628   Flags.version = Section.Version;
1629   Flags.isa_level = Section.ISALevel;
1630   Flags.isa_rev = Section.ISARevision;
1631   Flags.gpr_size = Section.GPRSize;
1632   Flags.cpr1_size = Section.CPR1Size;
1633   Flags.cpr2_size = Section.CPR2Size;
1634   Flags.fp_abi = Section.FpABI;
1635   Flags.isa_ext = Section.ISAExtension;
1636   Flags.ases = Section.ASEs;
1637   Flags.flags1 = Section.Flags1;
1638   Flags.flags2 = Section.Flags2;
1639   CBA.write((const char *)&Flags, sizeof(Flags));
1640 }
1641
1642 template <class ELFT>
1643 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1644                                          const ELFYAML::DynamicSection &Section,
1645                                          ContiguousBlobAccumulator &CBA) {
1646   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
1647          "Section type is not SHT_DYNAMIC");
1648
1649   if (!Section.Entries)
1650     return;
1651
1652   for (const ELFYAML::DynamicEntry &DE : *Section.Entries) {
1653     CBA.write<uintX_t>(DE.Tag, ELFT::TargetEndianness);
1654     CBA.write<uintX_t>(DE.Val, ELFT::TargetEndianness);
1655   }
1656   SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
1657 }
1658
1659 template <class ELFT>
1660 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1661                                          const ELFYAML::AddrsigSection &Section,
1662                                          ContiguousBlobAccumulator &CBA) {
1663   if (!Section.Symbols)
1664     return;
1665
1666   if (!Section.Symbols)
1667     return;
1668
1669   for (StringRef Sym : *Section.Symbols)
1670     SHeader.sh_size +=
1671         CBA.writeULEB128(toSymbolIndex(Sym, Section.Name, /*IsDynamic=*/false));
1672 }
1673
1674 template <class ELFT>
1675 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1676                                          const ELFYAML::NoteSection &Section,
1677                                          ContiguousBlobAccumulator &CBA) {
1678   if (!Section.Notes)
1679     return;
1680
1681   uint64_t Offset = CBA.tell();
1682   for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
1683     // Write name size.
1684     if (NE.Name.empty())
1685       CBA.write<uint32_t>(0, ELFT::TargetEndianness);
1686     else
1687       CBA.write<uint32_t>(NE.Name.size() + 1, ELFT::TargetEndianness);
1688
1689     // Write description size.
1690     if (NE.Desc.binary_size() == 0)
1691       CBA.write<uint32_t>(0, ELFT::TargetEndianness);
1692     else
1693       CBA.write<uint32_t>(NE.Desc.binary_size(), ELFT::TargetEndianness);
1694
1695     // Write type.
1696     CBA.write<uint32_t>(NE.Type, ELFT::TargetEndianness);
1697
1698     // Write name, null terminator and padding.
1699     if (!NE.Name.empty()) {
1700       CBA.write(NE.Name.data(), NE.Name.size());
1701       CBA.write('\0');
1702       CBA.padToAlignment(4);
1703     }
1704
1705     // Write description and padding.
1706     if (NE.Desc.binary_size() != 0) {
1707       CBA.writeAsBinary(NE.Desc);
1708       CBA.padToAlignment(4);
1709     }
1710   }
1711
1712   SHeader.sh_size = CBA.tell() - Offset;
1713 }
1714
1715 template <class ELFT>
1716 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
1717                                          const ELFYAML::GnuHashSection &Section,
1718                                          ContiguousBlobAccumulator &CBA) {
1719   if (!Section.HashBuckets)
1720     return;
1721
1722   if (!Section.Header)
1723     return;
1724
1725   // We write the header first, starting with the hash buckets count. Normally
1726   // it is the number of entries in HashBuckets, but the "NBuckets" property can
1727   // be used to override this field, which is useful for producing broken
1728   // objects.
1729   if (Section.Header->NBuckets)
1730     CBA.write<uint32_t>(*Section.Header->NBuckets, ELFT::TargetEndianness);
1731   else
1732     CBA.write<uint32_t>(Section.HashBuckets->size(), ELFT::TargetEndianness);
1733
1734   // Write the index of the first symbol in the dynamic symbol table accessible
1735   // via the hash table.
1736   CBA.write<uint32_t>(Section.Header->SymNdx, ELFT::TargetEndianness);
1737
1738   // Write the number of words in the Bloom filter. As above, the "MaskWords"
1739   // property can be used to set this field to any value.
1740   if (Section.Header->MaskWords)
1741     CBA.write<uint32_t>(*Section.Header->MaskWords, ELFT::TargetEndianness);
1742   else
1743     CBA.write<uint32_t>(Section.BloomFilter->size(), ELFT::TargetEndianness);
1744
1745   // Write the shift constant used by the Bloom filter.
1746   CBA.write<uint32_t>(Section.Header->Shift2, ELFT::TargetEndianness);
1747
1748   // We've finished writing the header. Now write the Bloom filter.
1749   for (llvm::yaml::Hex64 Val : *Section.BloomFilter)
1750     CBA.write<uintX_t>(Val, ELFT::TargetEndianness);
1751
1752   // Write an array of hash buckets.
1753   for (llvm::yaml::Hex32 Val : *Section.HashBuckets)
1754     CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1755
1756   // Write an array of hash values.
1757   for (llvm::yaml::Hex32 Val : *Section.HashValues)
1758     CBA.write<uint32_t>(Val, ELFT::TargetEndianness);
1759
1760   SHeader.sh_size = 16 /*Header size*/ +
1761                     Section.BloomFilter->size() * sizeof(typename ELFT::uint) +
1762                     Section.HashBuckets->size() * 4 +
1763                     Section.HashValues->size() * 4;
1764 }
1765
1766 template <class ELFT>
1767 void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
1768                                ContiguousBlobAccumulator &CBA) {
1769   size_t PatternSize = Fill.Pattern ? Fill.Pattern->binary_size() : 0;
1770   if (!PatternSize) {
1771     CBA.writeZeros(Fill.Size);
1772     return;
1773   }
1774
1775   // Fill the content with the specified pattern.
1776   uint64_t Written = 0;
1777   for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
1778     CBA.writeAsBinary(*Fill.Pattern);
1779   CBA.writeAsBinary(*Fill.Pattern, Fill.Size - Written);
1780 }
1781
1782 template <class ELFT>
1783 DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
1784   const ELFYAML::SectionHeaderTable &SectionHeaders =
1785       Doc.getSectionHeaderTable();
1786   if (SectionHeaders.IsImplicit || SectionHeaders.NoHeaders ||
1787       SectionHeaders.isDefault())
1788     return DenseMap<StringRef, size_t>();
1789
1790   DenseMap<StringRef, size_t> Ret;
1791   size_t SecNdx = 0;
1792   StringSet<> Seen;
1793
1794   auto AddSection = [&](const ELFYAML::SectionHeader &Hdr) {
1795     if (!Ret.try_emplace(Hdr.Name, ++SecNdx).second)
1796       reportError("repeated section name: '" + Hdr.Name +
1797                   "' in the section header description");
1798     Seen.insert(Hdr.Name);
1799   };
1800
1801   if (SectionHeaders.Sections)
1802     for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Sections)
1803       AddSection(Hdr);
1804
1805   if (SectionHeaders.Excluded)
1806     for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
1807       AddSection(Hdr);
1808
1809   for (const ELFYAML::Section *S : Doc.getSections()) {
1810     // Ignore special first SHT_NULL section.
1811     if (S == Doc.getSections().front())
1812       continue;
1813     if (!Seen.count(S->Name))
1814       reportError("section '" + S->Name +
1815                   "' should be present in the 'Sections' or 'Excluded' lists");
1816     Seen.erase(S->Name);
1817   }
1818
1819   for (const auto &It : Seen)
1820     reportError("section header contains undefined section '" + It.getKey() +
1821                 "'");
1822   return Ret;
1823 }
1824
1825 template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
1826   // A YAML description can have an explicit section header declaration that
1827   // allows to change the order of section headers.
1828   DenseMap<StringRef, size_t> ReorderMap = buildSectionHeaderReorderMap();
1829
1830   if (HasError)
1831     return;
1832
1833   // Build excluded section headers map.
1834   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
1835   const ELFYAML::SectionHeaderTable &SectionHeaders =
1836       Doc.getSectionHeaderTable();
1837   if (SectionHeaders.Excluded)
1838     for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
1839       if (!ExcludedSectionHeaders.insert(Hdr.Name).second)
1840         llvm_unreachable("buildSectionIndex() failed");
1841
1842   if (SectionHeaders.NoHeaders.getValueOr(false))
1843     for (const ELFYAML::Section *S : Sections)
1844       if (!ExcludedSectionHeaders.insert(S->Name).second)
1845         llvm_unreachable("buildSectionIndex() failed");
1846
1847   size_t SecNdx = -1;
1848   for (const ELFYAML::Section *S : Sections) {
1849     ++SecNdx;
1850
1851     size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(S->Name);
1852     if (!SN2I.addName(S->Name, Index))
1853       llvm_unreachable("buildSectionIndex() failed");
1854
1855     if (!ExcludedSectionHeaders.count(S->Name))
1856       ShStrtabStrings->add(ELFYAML::dropUniqueSuffix(S->Name));
1857   }
1858 }
1859
1860 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {
1861   auto Build = [this](ArrayRef<ELFYAML::Symbol> V, NameToIdxMap &Map) {
1862     for (size_t I = 0, S = V.size(); I < S; ++I) {
1863       const ELFYAML::Symbol &Sym = V[I];
1864       if (!Sym.Name.empty() && !Map.addName(Sym.Name, I + 1))
1865         reportError("repeated symbol name: '" + Sym.Name + "'");
1866     }
1867   };
1868
1869   if (Doc.Symbols)
1870     Build(*Doc.Symbols, SymN2I);
1871   if (Doc.DynamicSymbols)
1872     Build(*Doc.DynamicSymbols, DynSymN2I);
1873 }
1874
1875 template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
1876   // Add the regular symbol names to .strtab section.
1877   if (Doc.Symbols)
1878     for (const ELFYAML::Symbol &Sym : *Doc.Symbols)
1879       DotStrtab.add(ELFYAML::dropUniqueSuffix(Sym.Name));
1880   DotStrtab.finalize();
1881
1882   // Add the dynamic symbol names to .dynstr section.
1883   if (Doc.DynamicSymbols)
1884     for (const ELFYAML::Symbol &Sym : *Doc.DynamicSymbols)
1885       DotDynstr.add(ELFYAML::dropUniqueSuffix(Sym.Name));
1886
1887   // SHT_GNU_verdef and SHT_GNU_verneed sections might also
1888   // add strings to .dynstr section.
1889   for (const ELFYAML::Chunk *Sec : Doc.getSections()) {
1890     if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec)) {
1891       if (VerNeed->VerneedV) {
1892         for (const ELFYAML::VerneedEntry &VE : *VerNeed->VerneedV) {
1893           DotDynstr.add(VE.File);
1894           for (const ELFYAML::VernauxEntry &Aux : VE.AuxV)
1895             DotDynstr.add(Aux.Name);
1896         }
1897       }
1898     } else if (auto VerDef = dyn_cast<ELFYAML::VerdefSection>(Sec)) {
1899       if (VerDef->Entries)
1900         for (const ELFYAML::VerdefEntry &E : *VerDef->Entries)
1901           for (StringRef Name : E.VerNames)
1902             DotDynstr.add(Name);
1903     }
1904   }
1905
1906   DotDynstr.finalize();
1907
1908   // Don't finalize the section header string table a second time if it has
1909   // already been finalized due to being one of the symbol string tables.
1910   if (ShStrtabStrings != &DotStrtab && ShStrtabStrings != &DotDynstr)
1911     ShStrtabStrings->finalize();
1912 }
1913
1914 template <class ELFT>
1915 bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
1916                               yaml::ErrorHandler EH, uint64_t MaxSize) {
1917   ELFState<ELFT> State(Doc, EH);
1918   if (State.HasError)
1919     return false;
1920
1921   // Build the section index, which adds sections to the section header string
1922   // table first, so that we can finalize the section header string table.
1923   State.buildSectionIndex();
1924   State.buildSymbolIndexes();
1925
1926   // Finalize section header string table and the .strtab and .dynstr sections.
1927   // We do this early because we want to finalize the string table builders
1928   // before writing the content of the sections that might want to use them.
1929   State.finalizeStrings();
1930
1931   if (State.HasError)
1932     return false;
1933
1934   std::vector<Elf_Phdr> PHeaders;
1935   State.initProgramHeaders(PHeaders);
1936
1937   // XXX: This offset is tightly coupled with the order that we write
1938   // things to `OS`.
1939   const size_t SectionContentBeginOffset =
1940       sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
1941   // It is quite easy to accidentally create output with yaml2obj that is larger
1942   // than intended, for example, due to an issue in the YAML description.
1943   // We limit the maximum allowed output size, but also provide a command line
1944   // option to change this limitation.
1945   ContiguousBlobAccumulator CBA(SectionContentBeginOffset, MaxSize);
1946
1947   std::vector<Elf_Shdr> SHeaders;
1948   State.initSectionHeaders(SHeaders, CBA);
1949
1950   // Now we can decide segment offsets.
1951   State.setProgramHeaderLayout(PHeaders, SHeaders);
1952
1953   bool ReachedLimit = CBA.getOffset() > MaxSize;
1954   if (Error E = CBA.takeLimitError()) {
1955     // We report a custom error message instead below.
1956     consumeError(std::move(E));
1957     ReachedLimit = true;
1958   }
1959
1960   if (ReachedLimit)
1961     State.reportError(
1962         "the desired output size is greater than permitted. Use the "
1963         "--max-size option to change the limit");
1964
1965   if (State.HasError)
1966     return false;
1967
1968   State.writeELFHeader(OS);
1969   writeArrayData(OS, makeArrayRef(PHeaders));
1970
1971   const ELFYAML::SectionHeaderTable &SHT = Doc.getSectionHeaderTable();
1972   if (!SHT.NoHeaders.getValueOr(false))
1973     CBA.updateDataAt(*SHT.Offset, SHeaders.data(),
1974                      SHT.getNumHeaders(SHeaders.size()) * sizeof(Elf_Shdr));
1975
1976   CBA.writeBlobToStream(OS);
1977   return true;
1978 }
1979
1980 namespace llvm {
1981 namespace yaml {
1982
1983 bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
1984               uint64_t MaxSize) {
1985   bool IsLE = Doc.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
1986   bool Is64Bit = Doc.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
1987   if (Is64Bit) {
1988     if (IsLE)
1989       return ELFState<object::ELF64LE>::writeELF(Out, Doc, EH, MaxSize);
1990     return ELFState<object::ELF64BE>::writeELF(Out, Doc, EH, MaxSize);
1991   }
1992   if (IsLE)
1993     return ELFState<object::ELF32LE>::writeELF(Out, Doc, EH, MaxSize);
1994   return ELFState<object::ELF32BE>::writeELF(Out, Doc, EH, MaxSize);
1995 }
1996
1997 } // namespace yaml
1998 } // namespace llvm