[WebAssembly] Update dylink section parsing

[sbc100]

Summary

This updates the format of the dylink section in accordance with
recent "spec" change:

https://github.com/WebAssembly/tool-conventions/pull/77

[sbc100]

• update test

include/llvm/BinaryFormat/Wasm.h

struct WasmObjectHeader {
   uint32_t Version;
 };
 
 struct WasmDylinkInfo {
   uint32_t MemorySize; // Memory size in bytes
   uint32_t MemoryAlignment;  // P2 alignment of memory
   uint32_t TableSize;  // Table size in elements
   uint32_t TableAlignment;  // P2 alignment of table
+  std::vector<StringRef> Needed;  // Shared library depenedencies
 };
 
 struct WasmExport {
   StringRef Name;
   uint8_t Kind;
   uint32_t Index;
 };
 

include/llvm/Object/Wasm.h

public:
 
   section_iterator section_begin() const override;
   section_iterator section_end() const override;
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
+  bool isSharedObject() const;
 
   struct ReadContext {
     const uint8_t *Start;
     const uint8_t *Ptr;
     const uint8_t *End;
   };
 
 private:
private:
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   std::vector<wasm::WasmFunctionName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
+  bool HasDylinkSection = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedEvents = 0;
   uint32_t CodeSection = 0;
   uint32_t DataSection = 0;
   uint32_t GlobalSection = 0;
   uint32_t EventSection = 0;

include/llvm/ObjectYAML/WasmYAML.h

static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "dylink";
   }
 
   uint32_t MemorySize;
   uint32_t MemoryAlignment;
   uint32_t TableSize;
   uint32_t TableAlignment;
+  std::vector<StringRef> Needed;
 };
 
 struct NameSection : CustomSection {
   NameSection() : CustomSection("name") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "name";

lib/Object/WasmObjectFile.cpp

 }
 
 Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
   DylinkInfo.MemorySize = readVaruint32(Ctx);
   DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
   DylinkInfo.TableSize = readVaruint32(Ctx);
   DylinkInfo.TableAlignment = readVaruint32(Ctx);
+  uint32_t Count = readVaruint32(Ctx);
+  while (Count--) {
+    DylinkInfo.Needed.push_back(readString(Ctx));
+  }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("dylink section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
   llvm::DenseSet<uint64_t> Seen;

 Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
 
 SubtargetFeatures WasmObjectFile::getFeatures() const {
   return SubtargetFeatures();
 }
 
 bool WasmObjectFile::isRelocatableObject() const { return HasLinkingSection; }
 
+bool WasmObjectFile::isSharedObject() const { return HasDylinkSection; }
+
 const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
   assert(Ref.d.a < Sections.size());
   return Sections[Ref.d.a];
 }
 
 const WasmSection &
 WasmObjectFile::getWasmSection(const SectionRef &Section) const {
   return getWasmSection(Section.getRawDataRefImpl());

lib/ObjectYAML/WasmYAML.cpp

 
 static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("MemorySize", Section.MemorySize);
   IO.mapRequired("MemoryAlignment", Section.MemoryAlignment);
   IO.mapRequired("TableSize", Section.TableSize);
   IO.mapRequired("TableAlignment", Section.TableAlignment);
+  IO.mapRequired("Needed", Section.Needed);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
 }
 

test/ObjectYAML/wasm/dylink_section.yaml

 # RUN: yaml2obj %s | obj2yaml | FileCheck %s
 --- !WASM
 FileHeader:
   Version:         0x00000001
 
 Sections:
   - Type:            CUSTOM
     Name:            dylink
     MemorySize:      4
     MemoryAlignment: 2
     TableSize:       1
     TableAlignment:  0
+    Needed:          [ libfoo.so, libbar.so ]
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            dylink
 # CHECK:     MemorySize:      4
 # CHECK:     MemoryAlignment: 2
 # CHECK:     TableSize:       1
 # CHECK:     TableAlignment:  0
+# CHECK:     Needed:
+# CHECK:       - libfoo.so
+# CHECK:       - libbar.so
 # CHECK: ...

tools/obj2yaml/wasm2yaml.cpp

WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
   if (WasmSec.Name == "dylink") {
     std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
         make_unique<WasmYAML::DylinkSection>();
     const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
     DylinkSec->MemorySize = Info.MemorySize;
     DylinkSec->MemoryAlignment = Info.MemoryAlignment;
     DylinkSec->TableSize = Info.TableSize;
     DylinkSec->TableAlignment = Info.TableAlignment;
+    DylinkSec->Needed = Info.Needed;
     CustomSec = std::move(DylinkSec);
   } else if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::NameSection> NameSec =
         make_unique<WasmYAML::NameSection>();
     for (const llvm::wasm::WasmFunctionName &Func : Obj.debugNames()) {
       WasmYAML::NameEntry NameEntry;
       NameEntry.Name = Func.Name;
       NameEntry.Index = Func.Index;

tools/yaml2obj/yaml2wasm.cpp

 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::DylinkSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.MemorySize, OS);
   encodeULEB128(Section.MemoryAlignment, OS);
   encodeULEB128(Section.TableSize, OS);
   encodeULEB128(Section.TableAlignment, OS);
+  encodeULEB128(Section.Needed.size(), OS);
+  for (StringRef Needed : Section.Needed) {
+    writeStringRef(Needed, OS);
+  }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::LinkingSection &Section) {
   writeStringRef(Section.Name, OS);
   encodeULEB128(Section.Version, OS);