[yaml2obj/obj2yaml] - Add support for SHT_LLVM_DEPENDENT_LIBRARIES sections.

[grimar]

Summary

This section contains strings specifying libraries to be added to the link by the linker.
The strings are encoded as standard null-terminated UTF-8 strings.

This patch adds a way to describe and dump SHT_LLVM_DEPENDENT_LIBRARIES sections.

I introduced a new YAMLFlowString type here. That used to teach obj2yaml to dump
them like:

Libraries: [ foo, bar ]

instead of the following (if StringRef would be used):

Libraries:
  - foo
  - bar

[MaskRay]

llvm/lib/ObjectYAML/ELFEmitter.cpp

947

() can be omitted.

llvm/test/tools/yaml2obj/ELF/llvm-deplibs-section.yaml

67

Align the values.

llvm/tools/obj2yaml/elf2yaml.cpp

661

(I) -> I

[grimar]

• Addressed review comments.

[jhenderson]

LGTM, with a couple of nits.

llvm/test/tools/obj2yaml/llvm-deplibs-section.yaml

27

to dump -> when dumping

also for case 3 and 4.

(I think that more clearly says that the interesting bit is "Libraries" in the output).

31

but section now has -> but the section has

llvm/include/llvm/ObjectYAML/ELFYAML.h

 
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
 LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)
 
+LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)
+
 // For now, hardcode 64 bits everywhere that 32 or 64 would be needed
 // since 64-bit can hold 32-bit values too.
 struct FileHeader {
   ELF_ELFCLASS Class;
   ELF_ELFDATA Data;
   ELF_ELFOSABI OSABI;
   llvm::yaml::Hex8 ABIVersion;
   ELF_ET Type;
enum class ChunkKind {
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     MipsABIFlags,
     Addrsig,
     Fill,
     LinkerOptions,
+    DependentLibraries,
   };
 
   ChunkKind Kind;
   StringRef Name;
 
   Chunk(ChunkKind K) : Kind(K) {}
   virtual ~Chunk();
 };
struct LinkerOptionsSection : Section {
 
   LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
 
   static bool classof(const Chunk *S) {
     return S->Kind == ChunkKind::LinkerOptions;
   }
 };
 
+struct DependentLibrariesSection : Section {
+  Optional<std::vector<YAMLFlowString>> Libs;
+  Optional<yaml::BinaryRef> Content;
+
+  DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::DependentLibraries;
+  }
+};
+
 struct SymverSection : Section {
   std::vector<uint16_t> Entries;
 
   SymverSection() : Section(ChunkKind::Symver) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
 };
 

llvm/lib/ObjectYAML/ELFEmitter.cpp

void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::NoteSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::GnuHashSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::LinkerOptionsSection &Section,
                            ContiguousBlobAccumulator &CBA);
+  void writeSectionContent(Elf_Shdr &SHeader,
+                           const ELFYAML::DependentLibrariesSection &Section,
+                           ContiguousBlobAccumulator &CBA);
 
   void writeFill(ELFYAML::Fill &Fill, ContiguousBlobAccumulator &CBA);
 
   ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH);
 
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     } else if (auto S = dyn_cast<ELFYAML::AddrsigSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::LinkerOptionsSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::NoteSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::GnuHashSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
+    } else if (auto S = dyn_cast<ELFYAML::DependentLibrariesSection>(Sec)) {
+      writeSectionContent(SHeader, *S, CBA);
     } else {
       llvm_unreachable("Unknown section type");
     }
 
     // Override the fields if requested.
     if (Sec) {
       if (Sec->ShName)
         SHeader.sh_name = *Sec->ShName;
for (const ELFYAML::LinkerOption &LO : *Section.Options) {
     OS.write('\0');
     OS.write(LO.Value.data(), LO.Value.size());
     OS.write('\0');
     SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
   }
 }
 
 template <class ELFT>
+void ELFState<ELFT>::writeSectionContent(
+    Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
+    ContiguousBlobAccumulator &CBA) {
+  raw_ostream &OS =
+      CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
+
+  if (Section.Content) {
+    SHeader.sh_size = writeContent(OS, Section.Content, None);
+    return;
+  }
+
+  if (!Section.Libs)
+    return;
+
+  for (StringRef Lib : *Section.Libs) {
+    OS.write(Lib.data(), Lib.size());
+    OS.write('\0');
+    SHeader.sh_size += Lib.size() + 1;
+  }
+}
+
+template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   raw_ostream &OS =
       CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign);
 
   unsigned Link = 0;
   if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))

llvm/lib/ObjectYAML/ELFYAML.cpp

static StringRef input(StringRef Scalar, void *, StOtherPiece &Val) {
     return {};
   }
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 template <> struct SequenceElementTraits<StOtherPiece> {
   static const bool flow = true;
 };
 
+template <> struct ScalarTraits<ELFYAML::YAMLFlowString> {
+  static void output(const ELFYAML::YAMLFlowString &Val, void *,
+                     raw_ostream &Out) {
+    Out << Val;
+  }
+  static StringRef input(StringRef Scalar, void *,
+                         ELFYAML::YAMLFlowString &Val) {
+    Val = Scalar;
+    return {};
+  }
+  static QuotingType mustQuote(StringRef S) {
+    return ScalarTraits<StringRef>::mustQuote(S);
+  }
+};
+template <> struct SequenceElementTraits<ELFYAML::YAMLFlowString> {
+  static const bool flow = true;
+};
+
 namespace {
 
 struct NormalizedOther {
   NormalizedOther(IO &IO) : YamlIO(IO) {}
   NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
     assert(Original && "This constructor is only used for outputting YAML and "
                        "assumes a non-empty Original");
     std::vector<StOtherPiece> Ret;

 }
 
 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Options", Section.Options);
   IO.mapOptional("Content", Section.Content);
 }
 
+static void sectionMapping(IO &IO,
+                           ELFYAML::DependentLibrariesSection &Section) {
+  commonSectionMapping(IO, Section);
+  IO.mapOptional("Libraries", Section.Libs);
+  IO.mapOptional("Content", Section.Content);
+}
+
 void MappingTraits<ELFYAML::SectionOrType>::mapping(
     IO &IO, ELFYAML::SectionOrType &sectionOrType) {
   IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
 }
 
 void MappingTraits<ELFYAML::SectionName>::mapping(
     IO &IO, ELFYAML::SectionName &sectionName) {
   IO.mapRequired("Section", sectionName.Section);
if (!IO.outputting())
       Section.reset(new ELFYAML::AddrsigSection());
     sectionMapping(IO, *cast<ELFYAML::AddrsigSection>(Section.get()));
     break;
   case ELF::SHT_LLVM_LINKER_OPTIONS:
     if (!IO.outputting())
       Section.reset(new ELFYAML::LinkerOptionsSection());
     sectionMapping(IO, *cast<ELFYAML::LinkerOptionsSection>(Section.get()));
     break;
+  case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
+    if (!IO.outputting())
+      Section.reset(new ELFYAML::DependentLibrariesSection());
+    sectionMapping(IO,
+                   *cast<ELFYAML::DependentLibrariesSection>(Section.get()));
+    break;
   default:
     if (!IO.outputting()) {
       StringRef Name;
       IO.mapOptional("Name", Name, StringRef());
       Name = ELFYAML::dropUniqueSuffix(Name);
 
       if (ELFYAML::StackSizesSection::nameMatches(Name))
         Section = std::make_unique<ELFYAML::StackSizesSection>();
StringRef MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
   }
 
   if (const auto *Sec = dyn_cast<ELFYAML::LinkerOptionsSection>(C.get())) {
     if (Sec->Options && Sec->Content)
       return "\"Options\" and \"Content\" can't be used together";
     return {};
   }
 
+  if (const auto *Sec = dyn_cast<ELFYAML::DependentLibrariesSection>(C.get())) {
+    if (Sec->Libs && Sec->Content)
+      return "SHT_LLVM_DEPENDENT_LIBRARIES: \"Libraries\" and \"Content\" "
+             "can't "
+             "be used together";
+    return {};
+  }
+
   if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
     if (!F->Pattern)
       return {};
     if (F->Pattern->binary_size() != 0 && !F->Size)
       return "\"Size\" can't be 0 when \"Pattern\" is not empty";
     return {};
   }
 

llvm/test/tools/obj2yaml/llvm-deplibs-section.yaml

+## Check how obj2yaml produces SHT_LLVM_DEPENDENT_LIBRARIES section descriptions.
+
+# RUN: yaml2obj %s -o %t
+# RUN: obj2yaml %t | FileCheck %s
+
+# CHECK:      Sections:
+# CHECK-NEXT:  - Name:      .deplibs.single
+# CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+# CHECK-NEXT:    Libraries: [ foo ]
+# CHECK-NEXT:  - Name:      .deplibs.multiple
+# CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+# CHECK-NEXT:    Libraries: [ foo, bar, foo ]
+# CHECK-NEXT:  - Name:      .deplibs.empty
+# CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+# CHECK-NEXT:    Libraries: [  ]
+# CHECK-NEXT:  - Name:      .deplibs.nonul
+# CHECK-NEXT:    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+# CHECK-NEXT:    Content:   666F6F
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+## Case 1: test we use "Libraries" to dump a valid section with a null-terminated string.
+  - Name:      .deplibs.single
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ foo ]
+## Case 2: the same, but section now has multiple strings.
+  - Name:      .deplibs.multiple
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ foo, bar, foo ]
+## Case 3: test we use "Libraries" to dump an empty section.
+  - Name:      .deplibs.empty
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ ]
+## Case 4: test we use "Content" to dump a non-null terminated section.
+  - Name:      .deplibs.nonul
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Content:   "666f6f"

llvm/test/tools/yaml2obj/ELF/llvm-deplibs-section.yaml

+## Check how yaml2obj produces SHT_LLVM_DEPENDENT_LIBRARIES sections.
+
+## Check we can describe SHT_LLVM_DEPENDENT_LIBRARIES using
+## "Libraries" and "Content" properies.
+
+# RUN: yaml2obj --docnum=1 %s -o %t1
+# RUN: llvm-readobj --sections --section-data %t1 | FileCheck %s --check-prefix=LIBRARIES
+
+# LIBRARIES:      Name: .deplibs.lib
+# LIBRARIES-NEXT: Type: SHT_LLVM_DEPENDENT_LIBRARIES (0x6FFF4C04)
+# LIBRARIES-NEXT: Flags [ (0x0)
+# LIBRARIES-NEXT: ]
+# LIBRARIES-NEXT: Address: 0x0
+# LIBRARIES-NEXT: Offset: 0x40
+# LIBRARIES-NEXT: Size: 12
+# LIBRARIES-NEXT: Link: 0
+# LIBRARIES-NEXT: Info: 0
+# LIBRARIES-NEXT: AddressAlignment: 0
+# LIBRARIES-NEXT: EntrySize: 0
+# LIBRARIES-NEXT: SectionData (
+# LIBRARIES-NEXT:   0000: 666F6F00 62617200 666F6F00 |foo.bar.foo.|
+# LIBRARIES-NEXT: )
+
+# LIBRARIES:      Name: .deplibs.content
+# LIBRARIES-NEXT: Type: SHT_LLVM_DEPENDENT_LIBRARIES
+# LIBRARIES-NEXT: Flags [
+# LIBRARIES-NEXT: ]
+# LIBRARIES-NEXT: Address: 0x0
+# LIBRARIES-NEXT: Offset: 0x4C
+# LIBRARIES-NEXT: Size: 3
+# LIBRARIES-NEXT: Link: 0
+# LIBRARIES-NEXT: Info: 0
+# LIBRARIES-NEXT: AddressAlignment: 0
+# LIBRARIES-NEXT: EntrySize: 0
+# LIBRARIES-NEXT: SectionData (
+# LIBRARIES-NEXT:   0000: 112233
+# LIBRARIES-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:      .deplibs.lib
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Libraries: [ foo, bar, foo ]
+  - Name:    .deplibs.content
+    Type:    SHT_LLVM_DEPENDENT_LIBRARIES
+    Content: "112233"
+
+## Check we report an error when "Libraries" and "Content" are used together.
+
+# RUN: not yaml2obj --docnum=2 %s 2>&1 | FileCheck %s --check-prefix=LIBS-CONTENT
+
+# LIBS-CONTENT: error: SHT_LLVM_DEPENDENT_LIBRARIES: "Libraries" and "Content" can't be used together
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:      .deplibs
+    Type:      SHT_LLVM_DEPENDENT_LIBRARIES
+    Content:   "FF"
+    Libraries: [ foo ]
+
+## Check we create an empty section when neither "Libraries" nor "Content" are specified.
+
+# RUN: yaml2obj --docnum=3 %s -o %t3
+# RUN: llvm-readelf --sections %t3 | FileCheck %s --check-prefix=NOPROPS
+
+# NOPROPS: [Nr] Name     Type                     Address          Off    Size
+# NOPROPS: [ 1] .deplibs LLVM_DEPENDENT_LIBRARIES 0000000000000000 000040 000000
+ 
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .deplibs
+    Type: SHT_LLVM_DEPENDENT_LIBRARIES

llvm/tools/obj2yaml/elf2yaml.cpp

Error dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                     ELFYAML::RelocationSection &S);
   template <class RelT>
   Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                        ELFYAML::Relocation &R);
 
   Expected<ELFYAML::AddrsigSection *> dumpAddrsigSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::LinkerOptionsSection *>
   dumpLinkerOptionsSection(const Elf_Shdr *Shdr);
+  Expected<ELFYAML::DependentLibrariesSection *>
+  dumpDependentLibrariesSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::RawContentSection *>
   dumpContentSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::SymtabShndxSection *>
   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
   Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
for (const Elf_Shdr &Sec : Sections) {
     case ELF::SHT_LLVM_LINKER_OPTIONS: {
       Expected<ELFYAML::LinkerOptionsSection *> SecOrErr =
           dumpLinkerOptionsSection(&Sec);
       if (!SecOrErr)
         return SecOrErr.takeError();
       Y->Chunks.emplace_back(*SecOrErr);
       break;
     }
+    case ELF::SHT_LLVM_DEPENDENT_LIBRARIES: {
+      Expected<ELFYAML::DependentLibrariesSection *> SecOrErr =
+          dumpDependentLibrariesSection(&Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      Y->Chunks.emplace_back(*SecOrErr);
+      break;
+    }
     case ELF::SHT_NULL: {
       // We only dump the SHT_NULL section at index 0 when it
       // has at least one non-null field, because yaml2obj
       // normally creates the zero section at index 0 implicitly.
       if (&Sec == &Sections[0]) {
         const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&Sec);
         const uint8_t *End = Begin + sizeof(Elf_Shdr);
         if (std::find_if(Begin, End, [](uint8_t V) { return V != 0; }) == End)
ELFDumper<ELFT>::dumpLinkerOptionsSection(const Elf_Shdr *Shdr) {
   S->Options.emplace();
   for (size_t I = 0, E = Strings.size(); I != E; I += 2)
     S->Options->push_back({Strings[I], Strings[I + 1]});
 
   return S.release();
 }
 
 template <class ELFT>
+Expected<ELFYAML::DependentLibrariesSection *>
+ELFDumper<ELFT>::dumpDependentLibrariesSection(const Elf_Shdr *Shdr) {
+  auto DL = std::make_unique<ELFYAML::DependentLibrariesSection>();
+  if (Error E = dumpCommonSection(Shdr, *DL))
+    return std::move(E);
+
+  Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return ContentOrErr.takeError();
+
+  ArrayRef<uint8_t> Content = *ContentOrErr;
+  if (!Content.empty() && Content.back() != 0) {
+    DL->Content = Content;
+    return DL.release();
+  }
+
+  DL->Libs.emplace();
+  for (const uint8_t *I = Content.begin(), *E = Content.end(); I < E;) {
+    StringRef Lib((const char *)I);
+    DL->Libs->emplace_back(Lib);
+    I += Lib.size() + 1;
+  }
+
+  return DL.release();
+}
+
+template <class ELFT>
 Expected<ELFYAML::DynamicSection *>
 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
   auto S = std::make_unique<ELFYAML::DynamicSection>();
   if (Error E = dumpCommonSection(Shdr, *S))
     return std::move(E);
 
   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
   if (!DynTagsOrErr)