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