[yaml2obj] Add optional ProgramHeader.Content

[namhyung]

Summary

For ELF core files, it needs a way to add raw contents from the program
header directly since core files don't have sections.

[jhenderson]

Do you really need this? We already have the ability to provide "filler" sections which are like regular sections except they don't have a corresponding section header. See https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/yaml2obj/ELF/custom-fill.yaml. (If you do actually need the new feature, you need to write tests for it too).

[namhyung]

Cool. I didn't know I can use that. With SectionHeaderTable.NoHeaders = true, it'll do all I need. Thanks for the info!

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct ProgramHeader {
   Optional<llvm::yaml::Hex64> FileSize;
   Optional<llvm::yaml::Hex64> MemSize;
   Optional<llvm::yaml::Hex64> Offset;
   Optional<StringRef> FirstSec;
   Optional<StringRef> LastSec;
 
   // This vector contains all chunks from [FirstSec, LastSec].
   std::vector<Chunk *> Chunks;
+
+  // This contains optional content when no sections are used.
+  // It should NOT be used with Chunks or other section contents.
+  Optional<yaml::BinaryRef> Content;
 };
 
 struct Object {
   FileHeader Header;
   std::vector<ProgramHeader> ProgramHeaders;
 
   // An object might contain output section descriptions as well as
   // custom data that does not belong to any section.

llvm/lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
                                ContiguousBlobAccumulator &CBA,
                                ELFYAML::Section *YAMLSec);
   void initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                               ContiguousBlobAccumulator &CBA,
                               ELFYAML::Section *YAMLSec);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
-                              std::vector<Elf_Shdr> &SHeaders);
+                              std::vector<Elf_Shdr> &SHeaders,
+                              ContiguousBlobAccumulator &CBA);
 
   std::vector<Fragment>
   getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
                    ArrayRef<typename ELFT::Shdr> SHeaders);
 
   void finalizeStrings();
   void writeELFHeader(raw_ostream &OS);
   void writeSectionContent(Elf_Shdr &SHeader,
for (const ELFYAML::Chunk *C : Phdr.Chunks) {
     const Elf_Shdr &H = SHeaders[SN2I.get(S->Name)];
     Ret.push_back({H.sh_offset, H.sh_size, H.sh_type, H.sh_addralign});
   }
   return Ret;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
-                                            std::vector<Elf_Shdr> &SHeaders) {
+                                            std::vector<Elf_Shdr> &SHeaders,
+                                            ContiguousBlobAccumulator &CBA) {
   uint32_t PhdrIdx = 0;
   for (auto &YamlPhdr : Doc.ProgramHeaders) {
     Elf_Phdr &PHeader = PHeaders[PhdrIdx++];
     std::vector<Fragment> Fragments = getPhdrFragments(YamlPhdr, SHeaders);
     if (!llvm::is_sorted(Fragments, [](const Fragment &A, const Fragment &B) {
           return A.Offset < B.Offset;
         }))
       reportError("sections in the program header with index " +
for (auto &YamlPhdr : Doc.ProgramHeaders) {
     } else {
       // Set the alignment of the segment to be the maximum alignment of the
       // sections so that by default the segment has a valid and sensible
       // alignment.
       PHeader.p_align = 1;
       for (const Fragment &F : Fragments)
         PHeader.p_align = std::max((uint64_t)PHeader.p_align, F.AddrAlign);
     }
+
+    if (YamlPhdr.Content) {
+      alignToOffset(CBA, PHeader.p_align,
+                    yaml::Hex64(PHeader.p_paddr + PHeader.p_offset));
+      CBA.writeAsBinary(*YamlPhdr.Content);
+    }
   }
 }
 
 bool llvm::ELFYAML::shouldAllocateFileSpace(
     ArrayRef<ELFYAML::ProgramHeader> Phdrs, const ELFYAML::NoBitsSection &S) {
   for (const ELFYAML::ProgramHeader &PH : Phdrs) {
     auto It = llvm::find_if(
         PH.Chunks, [&](ELFYAML::Chunk *C) { return C->Name == S.Name; });
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
   // We limit the maximum allowed output size, but also provide a command line
   // option to change this limitation.
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset, MaxSize);
 
   std::vector<Elf_Shdr> SHeaders;
   State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets.
-  State.setProgramHeaderLayout(PHeaders, SHeaders);
+  State.setProgramHeaderLayout(PHeaders, SHeaders, CBA);
 
   bool ReachedLimit = CBA.getOffset() > MaxSize;
   if (Error E = CBA.takeLimitError()) {
     // We report a custom error message instead below.
     consumeError(std::move(E));
     ReachedLimit = true;
   }
 

llvm/lib/ObjectYAML/ELFYAML.cpp

void MappingTraits<ELFYAML::ProgramHeader>::mapping(
   IO.mapOptional("FirstSec", Phdr.FirstSec);
   IO.mapOptional("LastSec", Phdr.LastSec);
   IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
   IO.mapOptional("PAddr", Phdr.PAddr, Phdr.VAddr);
   IO.mapOptional("Align", Phdr.Align);
   IO.mapOptional("FileSize", Phdr.FileSize);
   IO.mapOptional("MemSize", Phdr.MemSize);
   IO.mapOptional("Offset", Phdr.Offset);
+  IO.mapOptional("Content", Phdr.Content);
 }
 
 std::string MappingTraits<ELFYAML::ProgramHeader>::validate(
     IO &IO, ELFYAML::ProgramHeader &FileHdr) {
   if (!FileHdr.FirstSec && FileHdr.LastSec)
     return "the \"LastSec\" key can't be used without the \"FirstSec\" key";
   if (FileHdr.FirstSec && !FileHdr.LastSec)
     return "the \"FirstSec\" key can't be used without the \"LastSec\" key";
+  if (FileHdr.FirstSec && FileHdr.Content)
+    return "the \"FirstSec\" key can't be used with \"Content\" key";
   return "";
 }
 
 LLVM_YAML_STRONG_TYPEDEF(StringRef, StOtherPiece)
 
 template <> struct ScalarTraits<StOtherPiece> {
   static void output(const StOtherPiece &Val, void *, raw_ostream &Out) {
     Out << Val;