[WebAssembly] Remove default -fdata-sections

[sbc100]

Summary

This reduces the number of wasm data sections that clang
will generate by default. -fdata-sections can still be
used to produce one segement per global variable.

This change also adds support for naming data segments
which is useful for the linker so that it can merge similar
sections.

[dschuff]

Do wer have any tests with global vars that have an explicit section? We should have one, that tests that they get merged into a segment in the object file.

include/llvm/BinaryFormat/Wasm.h

100

StringRefs generally shouldn't have lifetimes that extend beyond a callstack since they don't own their memory.
Edit: OK I tracked down where it actually comes from; I guess here (and below) can probably just have a comment like the one in MCSectionWasm's SectionName.

lib/MC/WasmObjectWriter.cpp

103

I guess this depends on D37834? I didn't notice before but it's kind of sad that we are duplicating this data structure from wasm.h

506

As mentioned in the other review, this can be SmallVectorImpl

1153

This bit implements the new behavior that each data section from the object file gets put into a separate segment, correct? IMO that is really the fundamental change of this patch, and the commit description should reflect that.

[sbc100]

Yes, this change is a WIP that depends on D37834.

[sbc100]

Rebase

[sunfish]

I apologize if I missed something, but what's the motivation for not using -fdata-sections by default?

[sbc100]

I guess I was just trying to match the other native toolchains. One can still pass -fdata-sections, but why make it the default?

I can remove the change in the default from this change to make it less controversial perhaps?

[sunfish]

I just have the same thought as @dschuff here. We're not even the first ones to do so, because CloudABI already does it. I also don't want to block you though.

[sbc100]

I created a more minimal version of this change https://reviews.llvm.org/D37876. Abandoning this one.

include/llvm/BinaryFormat/Wasm.h

struct WasmFunction {
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
 };
 
 struct WasmDataSegment {
   uint32_t MemoryIndex;
   WasmInitExpr Offset;
   ArrayRef<uint8_t> Content;
+  StringRef Name;
 };
 
 struct WasmElemSegment {
   uint32_t TableIndex;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 

 };
 
 // Linking metadata kinds.
 enum : unsigned {
   WASM_STACK_POINTER  = 0x1,
   WASM_SYMBOL_INFO    = 0x2,
   WASM_DATA_SIZE      = 0x3,
   WASM_DATA_ALIGNMENT = 0x4,
+  WASM_SEGMENT_NAMES  = 0x5,
 };
 
 enum : unsigned {
   WASM_SYMBOL_FLAG_WEAK = 0x1,
 };
 
 #define WASM_RELOC(name, value) name = value,
 

include/llvm/MC/MCSectionWasm.h

private:
 
   const MCSymbolWasm *Group;
 
   // The offset of the MC function/data section in the wasm code/data section.
   // For data relocations the offset is relative to start of the data payload
   // itself and does not include the size of the section header.
   uint64_t SectionOffset;
 
+  // For data sections, this is the offset of the corresponding wasm data
+  // segment
+  uint64_t MemoryOffset;
+
   friend class MCContext;
   MCSectionWasm(StringRef Section, unsigned type, SectionKind K,
                 const MCSymbolWasm *group, unsigned UniqueID, MCSymbol *Begin)
       : MCSection(SV_Wasm, K, Begin), SectionName(Section), Type(type),
-        UniqueID(UniqueID), Group(group), SectionOffset(0) {}
+        UniqueID(UniqueID), Group(group), SectionOffset(0) {
+    assert(type == wasm::WASM_SEC_CODE || type == wasm::WASM_SEC_DATA);
+  }
 
   void setSectionName(StringRef Name) { SectionName = Name; }
 
 public:
   ~MCSectionWasm();
 
   /// Decides whether a '.section' directive should be printed before the
   /// section name
public:
   bool isVirtualSection() const override;
 
   bool isUnique() const { return UniqueID != ~0U; }
   unsigned getUniqueID() const { return UniqueID; }
 
   uint64_t getSectionOffset() const { return SectionOffset; }
   void setSectionOffset(uint64_t Offset) { SectionOffset = Offset; }
 
+  uint32_t getMemoryOffset() const { return MemoryOffset; }
+  void setMemoryOffset(uint32_t Offset) { MemoryOffset = Offset; }
+
   static bool classof(const MCSection *S) { return S->getVariant() == SV_Wasm; }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/ObjectYAML/WasmYAML.h

 struct LinkingSection : CustomSection {
   LinkingSection() : CustomSection("linking") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "linking";
   }
 
-  std::vector<SymbolInfo> SymbolInfos;
   uint32_t DataSize;
   uint32_t DataAlignment;
+  std::vector<SymbolInfo> SymbolInfos;
+  std::vector<NameEntry> SegmentNames;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TYPE;
   }

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

static MCSectionWasm *selectWasmSectionForGlobal(
     const TargetMachine &TM, bool EmitUniqueSection, unsigned *NextUniqueID) {
   StringRef Group = "";
   if (getWasmComdat(GO))
     llvm_unreachable("comdat not yet supported for wasm");
 
   bool UniqueSectionNames = TM.getUniqueSectionNames();
   SmallString<128> Name = getSectionPrefixForGlobal(Kind);
 
+  uint32_t Type = wasm::WASM_SEC_DATA;
   if (const auto *F = dyn_cast<Function>(GO)) {
     const auto &OptionalPrefix = F->getSectionPrefix();
     if (OptionalPrefix)
       Name += *OptionalPrefix;
+    Type = wasm::WASM_SEC_CODE;
   }
 
   if (EmitUniqueSection && UniqueSectionNames) {
     Name.push_back('.');
     TM.getNameWithPrefix(Name, GO, Mang, true);
   }
   unsigned UniqueID = MCContext::GenericSectionID;
   if (EmitUniqueSection && !UniqueSectionNames) {
     UniqueID = *NextUniqueID;
     (*NextUniqueID)++;
   }
-  return Ctx.getWasmSection(Name, /*Type=*/0, Group, UniqueID);
+  return Ctx.getWasmSection(Name, Type, Group, UniqueID);
 }
 
 MCSection *TargetLoweringObjectFileWasm::SelectSectionForGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
 
   if (Kind.isCommon())
     report_fatal_error("mergable sections not supported yet on wasm");
 

lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initCOFFMCObjectFileInfo(const Triple &T) {
   StackMapSection = Ctx->getCOFFSection(".llvm_stackmaps",
                                         COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
                                             COFF::IMAGE_SCN_MEM_READ,
                                         SectionKind::getReadOnly());
 }
 
 void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // TODO: Set the section types and flags.
-  TextSection = Ctx->getWasmSection(".text", 0);
-  DataSection = Ctx->getWasmSection(".data", 0);
+  TextSection = Ctx->getWasmSection(".text", wasm::WASM_SEC_CODE);
+  DataSection = Ctx->getWasmSection(".data", wasm::WASM_SEC_DATA);
 
   // TODO: Set the section types and flags.
-  DwarfLineSection = Ctx->getWasmSection(".debug_line", 0);
-  DwarfStrSection = Ctx->getWasmSection(".debug_str", 0);
-  DwarfLocSection = Ctx->getWasmSection(".debug_loc", 0);
-  DwarfAbbrevSection = Ctx->getWasmSection(".debug_abbrev", 0, "section_abbrev");
-  DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", 0);
-  DwarfRangesSection = Ctx->getWasmSection(".debug_ranges", 0, "debug_range");
-  DwarfMacinfoSection = Ctx->getWasmSection(".debug_macinfo", 0, "debug_macinfo");
-  DwarfAddrSection = Ctx->getWasmSection(".debug_addr", 0);
-  DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", 0);
-  DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", 0);
-  DwarfInfoSection = Ctx->getWasmSection(".debug_info", 0, "section_info");
-  DwarfFrameSection = Ctx->getWasmSection(".debug_frame", 0);
-  DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", 0);
-  DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", 0);
+  DwarfLineSection = Ctx->getWasmSection(".debug_line", wasm::WASM_SEC_DATA);
+  DwarfStrSection = Ctx->getWasmSection(".debug_str", wasm::WASM_SEC_DATA);
+  DwarfLocSection = Ctx->getWasmSection(".debug_loc", wasm::WASM_SEC_DATA);
+  DwarfAbbrevSection = Ctx->getWasmSection(".debug_abbrev", wasm::WASM_SEC_DATA, "section_abbrev");
+  DwarfARangesSection = Ctx->getWasmSection(".debug_aranges", wasm::WASM_SEC_DATA);
+  DwarfRangesSection = Ctx->getWasmSection(".debug_ranges", wasm::WASM_SEC_DATA, "debug_range");
+  DwarfMacinfoSection = Ctx->getWasmSection(".debug_macinfo", wasm::WASM_SEC_DATA, "debug_macinfo");
+  DwarfAddrSection = Ctx->getWasmSection(".debug_addr", wasm::WASM_SEC_DATA);
+  DwarfCUIndexSection = Ctx->getWasmSection(".debug_cu_index", wasm::WASM_SEC_DATA);
+  DwarfTUIndexSection = Ctx->getWasmSection(".debug_tu_index", wasm::WASM_SEC_DATA);
+  DwarfInfoSection = Ctx->getWasmSection(".debug_info", wasm::WASM_SEC_DATA, "section_info");
+  DwarfFrameSection = Ctx->getWasmSection(".debug_frame", wasm::WASM_SEC_DATA);
+  DwarfPubNamesSection = Ctx->getWasmSection(".debug_pubnames", wasm::WASM_SEC_DATA);
+  DwarfPubTypesSection = Ctx->getWasmSection(".debug_pubtypes", wasm::WASM_SEC_DATA);
 
   // TODO: Define more sections.
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
                                             MCContext &ctx,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;

lib/MC/MCWasmStreamer.cpp

void MCWasmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                           unsigned ValueSize,
                                           unsigned MaxBytesToEmit) {
   MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, ValueSize,
                                          MaxBytesToEmit);
 }
 
 void MCWasmStreamer::EmitIdent(StringRef IdentString) {
   MCSection *Comment = getAssembler().getContext().getWasmSection(
-      ".comment", 0, 0);
+      ".comment", wasm::WASM_SEC_DATA);
   PushSection();
   SwitchSection(Comment);
   if (!SeenIdent) {
     EmitIntValue(0, 1);
     SeenIdent = true;
   }
   EmitBytes(IdentString);
   EmitIntValue(0, 1);

lib/MC/WasmObjectWriter.cpp

static bool isEqual(const WasmFunctionType &LHS,
     return LHS == RHS;
   }
 };
 
 // A wasm data segment.  A wasm binary contains only a single data section
 // but that can contain many segments, each with their own virtual location
 // in memory.  Each MCSection data created by llvm is modeled as its own
 // wasm data segment.
 struct WasmDataSegment {
   MCSectionWasm *Section;
+  StringRef Name;
   uint32_t Offset;
   SmallVector<char, 4> Data;
 };
 
 // A wasm import to be written into the import section.
 struct WasmImport {
   StringRef ModuleName;
   StringRef FieldName;
case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
-        << ", Type=" << Type << ", FixupSection=" << FixupSection;
+        << ", Type=" << Type
+        << ", FixupSection=" << FixupSection->getSectionName();
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 #if !defined(NDEBUG)
void reset() override {
     FunctionTypes.clear();
     Globals.clear();
     MCObjectWriter::reset();
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
+  void addGlobal(StringRef Name, uint32_t Value);
+
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
 
   void executePostLayoutBinding(MCAssembler &Asm,
                                 const MCAsmLayout &Layout) override;
 
   void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
private:
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         const SmallVector<WasmFunction, 4> &Functions);
   void writeDataSection(const SmallVector<WasmDataSegment, 4> &Segments);
   void writeNameSection(const SmallVector<WasmFunction, 4> &Functions,
                         const SmallVector<WasmImport, 4> &Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
-  void writeLinkingMetaDataSection(uint32_t DataSize, uint32_t DataAlignment,
-                                   ArrayRef<StringRef> WeakSymbols,
-                                   bool HasStackPointer,
-                                   uint32_t StackPointerGlobal);
+  void writeLinkingMetaDataSection(
+      const ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
+      uint32_t DataAlignment, ArrayRef<StringRef> WeakSymbols,
+      bool HasStackPointer, uint32_t StackPointerGlobal);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm& Symbol);
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   uint64_t Address = Global.InitialValue + RelEntry.Addend;
 
   // Ignore overflow. LLVM allows address arithmetic to silently wrap.
   uint32_t Value = Address;
 
   return Value;
 }
 
+static void addData(SmallVector<char, 0> &DataBytes, MCSectionWasm &DataSection,
+                    uint32_t &DataAlignment) {
+  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
+  DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
+  DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
+
+  for (const MCFragment &Frag : DataSection) {
+    if (Frag.hasInstructions())
+      report_fatal_error("only data supported in data sections");
+
+    if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
+      if (Align->getValueSize() != 1)
+        report_fatal_error("only byte values supported for alignment");
+      // If nops are requested, use zeros, as this is the data section.
+      uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
+      uint64_t Size = std::min<uint64_t>(alignTo(DataBytes.size(),
+                                                 Align->getAlignment()),
+                                         DataBytes.size() +
+                                             Align->getMaxBytesToEmit());
+      DataBytes.resize(Size, Value);
+    } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
+      DataBytes.insert(DataBytes.end(), Fill->getSize(), Fill->getValue());
+    } else {
+      const auto &DataFrag = cast<MCDataFragment>(Frag);
+      const SmallVectorImpl<char> &Contents = DataFrag.getContents();
+
+      DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
+    }
+  }
+
+  DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
+}
+
 uint32_t WasmObjectWriter::getRelocationIndexValue(
     const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     if (!IndirectSymbolIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found table index space: " +
                          RelEntry.Symbol->getName());
void WasmObjectWriter::writeCodeSection(
   for (const WasmFunction &Func : Functions) {
     auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
 
     int64_t Size = 0;
     if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
       report_fatal_error(".size expression must be evaluatable");
 
     encodeULEB128(Size, getStream());
-
     FuncSection.setSectionOffset(getStream().tell() - Section.ContentsOffset);
-
     Asm.writeSectionData(&FuncSection, Layout);
   }
 
   // Apply fixups.
   applyRelocations(CodeRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
void WasmObjectWriter::writeDataRelocSection() {
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
+    const ArrayRef<WasmDataSegment> Segments,
     uint32_t DataSize, uint32_t DataAlignment, ArrayRef<StringRef> WeakSymbols,
     bool HasStackPointer, uint32_t StackPointerGlobal) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
   if (HasStackPointer) {
     startSection(SubSection, wasm::WASM_STACK_POINTER);
if (DataSize > 0) {
     encodeULEB128(DataSize, getStream());
     endSection(SubSection);
 
     startSection(SubSection, wasm::WASM_DATA_ALIGNMENT);
     encodeULEB128(DataAlignment, getStream());
     endSection(SubSection);
   }
 
+  if (Segments.size()) {
+    startSection(SubSection, wasm::WASM_SEGMENT_NAMES);
+    encodeULEB128(Segments.size(), getStream());
+    for (const WasmDataSegment &Segment : Segments)
+      writeString(Segment.Name);
+    endSection(SubSection);
+  }
+
   endSection(Section);
 }
 
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
if (!WS.isDefined(/*SetUsed=*/false) || WS.isVariable()) {
 
       Imports.push_back(Import);
     }
   }
 
   // In the special .global_variables section, we've encoded global
   // variables used by the function. Translate them into the Globals
   // list.
-  MCSectionWasm *GlobalVars = Ctx.getWasmSection(".global_variables", 0, 0);
+  MCSectionWasm *GlobalVars = Ctx.getWasmSection(".global_variables", wasm::WASM_SEC_DATA);
   if (!GlobalVars->getFragmentList().empty()) {
     if (GlobalVars->getFragmentList().size() != 1)
       report_fatal_error("only one .global_variables fragment supported");
     const MCFragment &Frag = *GlobalVars->begin();
     if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
       report_fatal_error("only data supported in .global_variables");
     const auto &DataFrag = cast<MCDataFragment>(Frag);
     if (!DataFrag.getFixups().empty())
for (const uint8_t *p = (const uint8_t *)Contents.data(),
         p += n;
       }
       Globals.push_back(G);
     }
   }
 
   // In the special .stack_pointer section, we've encoded the stack pointer
   // index.
-  MCSectionWasm *StackPtr = Ctx.getWasmSection(".stack_pointer", 0, 0);
+  MCSectionWasm *StackPtr = Ctx.getWasmSection(".stack_pointer", wasm::WASM_SEC_DATA);
   if (!StackPtr->getFragmentList().empty()) {
     if (StackPtr->getFragmentList().size() != 1)
       report_fatal_error("only one .stack_pointer fragment supported");
     const MCFragment &Frag = *StackPtr->begin();
     if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
       report_fatal_error("only data supported in .stack_pointer");
     const auto &DataFrag = cast<MCDataFragment>(Frag);
     if (!DataFrag.getFixups().empty())
       report_fatal_error("fixups not supported in .stack_pointer");
     const SmallVectorImpl<char> &Contents = DataFrag.getContents();
     if (Contents.size() != 4)
       report_fatal_error("only one entry supported in .stack_pointer");
     HasStackPointer = true;
     StackPointerGlobal = NumGlobalImports + *(const int32_t *)Contents.data();
   }
 
+  for (MCSection &Sec : Asm) {
+    auto &Section = static_cast<MCSectionWasm &>(Sec);
+    if (Section.getType() != wasm::WASM_SEC_DATA)
+      continue;
+
+    DataSize = alignTo(DataSize, Section.getAlignment());
+    DataSegments.emplace_back();
+    WasmDataSegment &Segment = DataSegments.back();
+    Segment.Name = Section.getSectionName();
+    Segment.Offset = DataSize;
+    Segment.Section = &Section;
+    addData(Segment.Data, Section, DataAlignment);
+    DataSize += Segment.Data.size();
+    Section.setMemoryOffset(Segment.Offset);
+  }
+
   // Handle regular defined and undefined symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     // Ignore unnamed temporary symbols, which aren't ever exported, imported,
     // or used in relocations.
     if (S.isTemporary() && S.getName().empty())
       continue;
 
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
if (WS.isFunction()) {
       }
     } else {
       if (WS.isTemporary() && !WS.getSize())
         continue;
 
       if (!WS.isDefined(/*SetUsed=*/false))
         continue;
 
-      if (WS.getOffset() != 0)
-        report_fatal_error("data sections must contain one variable each: " +
-                           WS.getName());
       if (!WS.getSize())
         report_fatal_error("data symbols must have a size set with .size: " +
                            WS.getName());
 
       int64_t Size = 0;
       if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
         report_fatal_error(".size expression must be evaluatable");
 
-      auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
-
-      if (uint64_t(Size) != Layout.getSectionFileSize(&DataSection))
-        report_fatal_error("data sections must contain at most one variable");
-
-      DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
-
-      DataSegments.emplace_back();
-      WasmDataSegment &Segment = DataSegments.back();
-
-      DataSize = alignTo(DataSize, DataSection.getAlignment());
-      Segment.Offset = DataSize;
-      Segment.Section = &DataSection;
-
       // For each global, prepare a corresponding wasm global holding its
       // address.  For externals these will also be named exports.
       Index = NumGlobalImports + Globals.size();
+      auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
 
       WasmGlobal Global;
       Global.Type = PtrType;
       Global.IsMutable = false;
       Global.HasImport = false;
-      Global.InitialValue = DataSize;
+      Global.InitialValue = DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
       Global.ImportIndex = 0;
       SymbolIndices[&WS] = Index;
       DEBUG(dbgs() << "  -> global index: " << Index << "\n");
       Globals.push_back(Global);
-
-      for (const MCFragment &Frag : DataSection) {
-        if (Frag.hasInstructions())
-          report_fatal_error("only data supported in data sections");
-
-        if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
-          if (Align->getValueSize() != 1)
-            report_fatal_error("only byte values supported for alignment");
-          // If nops are requested, use zeros, as this is the data section.
-          uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
-          uint64_t Size = std::min<uint64_t>(
-              alignTo(Segment.Data.size(), Align->getAlignment()),
-              Segment.Data.size() + Align->getMaxBytesToEmit());
-          Segment.Data.resize(Size, Value);
-        } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
-          Segment.Data.insert(Segment.Data.end(), Fill->getSize(), Fill->getValue());
-        } else {
-          const auto &DataFrag = cast<MCDataFragment>(Frag);
-          const SmallVectorImpl<char> &Contents = DataFrag.getContents();
-
-          Segment.Data.insert(Segment.Data.end(), Contents.begin(),
-                              Contents.end());
-        }
-      }
-      DataSize += Segment.Data.size();
     }
 
     // If the symbol is visible outside this translation unit, export it.
     if ((WS.isExternal() && WS.isDefined(/*SetUsed=*/false))) {
       WasmExport Export;
       Export.FieldName = WS.getName();
       Export.Index = Index;
       if (WS.isFunction())
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeExportSection(Exports);
   // TODO: Start Section
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection(DataSegments);
   writeNameSection(Functions, Imports, NumFuncImports);
   writeCodeRelocSection();
   writeDataRelocSection();
-  writeLinkingMetaDataSection(DataSize, DataAlignment, WeakSymbols, HasStackPointer, StackPointerGlobal);
+  writeLinkingMetaDataSection(DataSegments, DataSize, DataAlignment,
+                              WeakSymbols, HasStackPointer, StackPointerGlobal);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 MCObjectWriter *llvm::createWasmObjectWriter(MCWasmObjectTargetWriter *MOTW,
                                              raw_pwrite_stream &OS) {
   return new WasmObjectWriter(MOTW, OS);
 }

lib/Object/WasmObjectFile.cpp

case wasm::WASM_SYMBOL_INFO: {
       break;
     }
     case wasm::WASM_DATA_SIZE:
       LinkingData.DataSize = readVaruint32(Ptr);
       break;
     case wasm::WASM_DATA_ALIGNMENT:
       LinkingData.DataAlignment = readVaruint32(Ptr);
       break;
+    case wasm::WASM_SEGMENT_NAMES: {
+      uint32_t Count = readVaruint32(Ptr);
+      if (Count > DataSegments.size())
+        return make_error<GenericBinaryError>("Too many segment names",
+                                              object_error::parse_failed);
+      for (uint32_t i = 0; i < Count; i++) {
+        DataSegments[i].Data.Name = readString(Ptr);
+        dbgs() << "segment name: " << DataSegments[i].Data.Name << "\n";
+      }
+      break;
+    }
     case wasm::WASM_STACK_POINTER:
     default:
       Ptr += Size;
       break;
     }
     if (Ptr != SubSectionEnd)
       return make_error<GenericBinaryError>(
           "Linking sub-section ended prematurely", object_error::parse_failed);

lib/ObjectYAML/WasmYAML.cpp

 }
 
 static void sectionMapping(IO &IO, WasmYAML::LinkingSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("DataSize", Section.DataSize);
   IO.mapRequired("DataAlignment", Section.DataAlignment);
   IO.mapOptional("SymbolInfo", Section.SymbolInfos);
+  IO.mapOptional("SegmentNames", Section.SegmentNames);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("Payload", Section.Payload);
 }
 

lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

WebAssemblyTargetMachine::WebAssemblyTargetMachine(
   // LLVM 'unreachable' to ISD::TRAP and then lower that to WebAssembly's
   // 'unreachable' instructions which is meant for that case.
   this->Options.TrapUnreachable = true;
 
   // WebAssembly treats each function as an independent unit. Force
   // -ffunction-sections, effectively, so that we can emit them independently.
   if (!TT.isOSBinFormatELF()) {
     this->Options.FunctionSections = true;
-    this->Options.DataSections = true;
-    this->Options.UniqueSectionNames = true;
   }
 
   initAsmInfo();
 
   // Note that we don't use setRequiresStructuredCFG(true). It disables
   // optimizations than we're ok with, and want, such as critical edge
   // splitting and tail merging.
 }

test/CodeGen/WebAssembly/global.ll

 ; CHECK:      ptr:
 ; CHECK-NEXT: .int32 arr+80
 ; CHECK-NEXT: .size ptr, 4
 @arr = global [128 x i32] zeroinitializer, align 16
 @ptr = global i32* getelementptr inbounds ([128 x i32], [128 x i32]* @arr, i32 0, i32 20), align 4
 
 ; Constant global.
 ; CHECK: .type    rom,@object{{$}}
-; CHECK: .section .rodata.rom,
+; CHECK: .section .rodata,
 ; CHECK: .globl   rom{{$}}
 ; CHECK: .p2align   4{{$}}
 ; CHECK: rom:
 ; CHECK: .skip    512{{$}}
 ; CHECK: .size    rom, 512{{$}}
 @rom = constant [128 x i32] zeroinitializer, align 16
 
 ; CHECK: .type       array,@object
 ; CHECK: array:
 ; CHECK-NEXT: .skip       8
 ; CHECK-NEXT: .size       array, 8
 ; CHECK: .type       pointer_to_array,@object
-; CHECK-NEXT: .section    .data.rel.ro.pointer_to_array,
+; CHECK-NEXT: .section    .data.rel.ro,
 ; CHECK-NEXT: .globl      pointer_to_array
 ; CHECK-NEXT: .p2align      2
 ; CHECK-NEXT: pointer_to_array:
 ; CHECK-NEXT: .int32      array+4
 ; CHECK-NEXT: .size       pointer_to_array, 4
 @array = internal constant [8 x i8] zeroinitializer, align 1
 @pointer_to_array = constant i8* getelementptr inbounds ([8 x i8], [8 x i8]* @array, i32 0, i32 4), align 4

test/CodeGen/WebAssembly/vtable.ll

 ; TYPEINFONAME-LABEL: _ZTS1C:
 ; TYPEINFONAME-NEXT: .asciz "1C"
 @_ZTS1C = constant [3 x i8] c"1C\00"
 ; TYPEINFONAME-LABEL: _ZTS1D:
 ; TYPEINFONAME-NEXT: .asciz "1D"
 @_ZTS1D = constant [3 x i8] c"1D\00"
 
 ; VTABLE:       .type _ZTV1A,@object
-; VTABLE-NEXT:  .section .data.rel.ro._ZTV1A,
+; VTABLE-NEXT:  .section .data.rel.ro,
 ; VTABLE-NEXT:  .globl _ZTV1A
 ; VTABLE-LABEL: _ZTV1A:
 ; VTABLE-NEXT:  .int32 0
 ; VTABLE-NEXT:  .int32 _ZTI1A
 ; VTABLE-NEXT:  .int32 _ZN1AD2Ev
 ; VTABLE-NEXT:  .int32 _ZN1AD0Ev
 ; VTABLE-NEXT:  .int32 _ZN1A3fooEv
 ; VTABLE-NEXT:  .size _ZTV1A, 20
 @_ZTV1A = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.A*)* @_ZN1AD0Ev to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A3fooEv to i8*)], align 4
 ; VTABLE:       .type _ZTV1B,@object
-; VTABLE-NEXT:  .section .data.rel.ro._ZTV1B,
 ; VTABLE-NEXT:  .globl _ZTV1B
 ; VTABLE-LABEL: _ZTV1B:
 ; VTABLE-NEXT:  .int32 0
 ; VTABLE-NEXT:  .int32 _ZTI1B
 ; VTABLE-NEXT:  .int32 _ZN1AD2Ev
 ; VTABLE-NEXT:  .int32 _ZN1BD0Ev
 ; VTABLE-NEXT:  .int32 _ZN1B3fooEv
 ; VTABLE-NEXT:  .size _ZTV1B, 20
 @_ZTV1B = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1B to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.B*)* @_ZN1BD0Ev to i8*), i8* bitcast (void (%struct.B*)* @_ZN1B3fooEv to i8*)], align 4
 ; VTABLE:       .type _ZTV1C,@object
-; VTABLE-NEXT:  .section .data.rel.ro._ZTV1C,
 ; VTABLE-NEXT:  .globl _ZTV1C
 ; VTABLE-LABEL: _ZTV1C:
 ; VTABLE-NEXT:  .int32 0
 ; VTABLE-NEXT:  .int32 _ZTI1C
 ; VTABLE-NEXT:  .int32 _ZN1AD2Ev
 ; VTABLE-NEXT:  .int32 _ZN1CD0Ev
 ; VTABLE-NEXT:  .int32 _ZN1C3fooEv
 ; VTABLE-NEXT:  .size _ZTV1C, 20
 @_ZTV1C = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1C to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.C*)* @_ZN1CD0Ev to i8*), i8* bitcast (void (%struct.C*)* @_ZN1C3fooEv to i8*)], align 4
 ; VTABLE:       .type _ZTV1D,@object
-; VTABLE-NEXT:  .section .data.rel.ro._ZTV1D,
 ; VTABLE-NEXT:  .globl _ZTV1D
 ; VTABLE-LABEL: _ZTV1D:
 ; VTABLE-NEXT:  .int32 0
 ; VTABLE-NEXT:  .int32 _ZTI1D
 ; VTABLE-NEXT:  .int32 _ZN1AD2Ev
 ; VTABLE-NEXT:  .int32 _ZN1DD0Ev
 ; VTABLE-NEXT:  .int32 _ZN1D3fooEv
 ; VTABLE-NEXT:  .size _ZTV1D, 20

test/MC/WebAssembly/array-fill.ll

 ; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
 ; PR33624
 
 source_filename = "ws.c"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"
 
 %struct.bd = type { i8 }
 
 @gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1
 
-; CHECK:  - Type:            DATA
-; CHECK:        Content:         '0102'
-; CHECK:    DataSize:        2
+; CHECK:        - Type:            DATA
+; CHECK:              Content:         '0102'
+; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        2
+; CHECK-NEXT:     DataAlignment:   1
+; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            .data
+

test/MC/WebAssembly/external-data.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 ; Verify relocations are correctly generated for addresses of externals
 ; in the data section.
 
 @myimport = external global i32, align 4
 
 @foo = global i64 7, align 4
 @bar = hidden global i32* @myimport, align 4
 
-; CHECK:        - Type:            DATA
-; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x00000013
-; CHECK-NEXT:     Segments:
-; CHECK-NEXT:       - SectionOffset:   6
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:         Content:         '0700000000000000'
-; CHECK-NEXT:       - SectionOffset:   19
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:         Content:         FFFFFFFF
+; CHECK:   - Type:            DATA
+; CHECK:     Relocations:
+; CHECK:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
+; CHECK:         Index:           0
+; CHECK:         Offset:          0x0000000E
+; CHECK:     Segments:
+; CHECK:       - SectionOffset:   6
+; CHECK:         MemoryIndex:     0
+; CHECK:         Offset:
+; CHECK:           Opcode:          I32_CONST
+; CHECK:           Value:           0
+; CHECK:         Content:         0700000000000000FFFFFFFF
+

test/MC/WebAssembly/reloc-data.ll

 ; RUN: llc -O0 -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | llvm-readobj -r -expand-relocs | FileCheck %s
 
 ; foo and bar are external and internal symbols.  a and b are pointers
 ; initialized to these locations offset by 2 and -2 elements respecitively.
 @foo = external global i32, align 4
 @bar = global i64 7, align 4
 @a = global i32* getelementptr (i32, i32* @foo, i32 2), align 8
 @b = global i64* getelementptr (i64, i64* @bar, i64 -2), align 8
-@c = global [3 x i32*] [i32* @foo, i32* @foo, i32* @foo], align 16
 
-; CHECK:      Format: WASM
-; CHECK:      Relocations [
-; CHECK-NEXT:   Section (6) DATA {
-; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
-; CHECK-NEXT:       Offset: 0x13
-; CHECK-NEXT:       Index: 0x0
-; CHECK-NEXT:       Addend: 8
-; CHECK-NEXT:     }
-; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
-; CHECK-NEXT:       Offset: 0x1C
-; CHECK-NEXT:       Index: 0x1
-; CHECK-NEXT:       Addend: -16
-; CHECK-NEXT:     }
-; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
-; CHECK-NEXT:       Offset: 0x25
-; CHECK-NEXT:       Index: 0x0
-; CHECK-NEXT:       Addend: 0
-; CHECK-NEXT:     }
-; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
-; CHECK-NEXT:       Offset: 0x29
-; CHECK-NEXT:       Index: 0x0
-; CHECK-NEXT:       Addend: 0
-; CHECK-NEXT:     }
-; CHECK-NEXT:     Relocation {
-; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
-; CHECK-NEXT:       Offset: 0x2D
-; CHECK-NEXT:       Index: 0x0
-; CHECK-NEXT:       Addend: 0
-; CHECK-NEXT:     }
-; CHECK-NEXT:   }
-; CHECK-NEXT: ]
+; CHECK: Format: WASM
+; CHECK: Relocations [
+; CHECK:   Section (6) DATA {
+; CHECK:     Relocation {
+; CHECK:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK:       Offset: 0xE
+; CHECK:       Index: 0x0
+; CHECK:       Addend: 8
+; CHECK:     }
+; CHECK:     Relocation {
+; CHECK:       Type: R_WEBASSEMBLY_MEMORY_ADDR_I32 (5)
+; CHECK:       Offset: 0x16
+; CHECK:       Index: 0x1
+; CHECK:       Addend: -16
+; CHECK:     }
+; CHECK:   }
+; CHECK: ]

test/MC/WebAssembly/unnamed-data.ll

 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            b
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x0000001C
+; CHECK-NEXT:         Offset:          0x00000017
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
 ; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:         Offset:          0x00000025
+; CHECK-NEXT:         Offset:          0x0000001F
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:         Content:         68656C6C6F00
-; CHECK-NEXT:       - SectionOffset:   17
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           6
-; CHECK-NEXT:         Content:         776F726C6400
-; CHECK-NEXT:       - SectionOffset:   28
+; CHECK-NEXT:         Content:         68656C6C6F00776F726C6400
+; CHECK-NEXT:       - SectionOffset:   23
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:         Content:         '00000000'
-; CHECK-NEXT:       - SectionOffset:   37
-; CHECK-NEXT:         MemoryIndex:     0
-; CHECK-NEXT:         Offset:          
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           24
-; CHECK-NEXT:         Content:         '06000000'
+; CHECK-NEXT:         Content:         '000000000000000006000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        28
 ; CHECK-NEXT:     DataAlignment:   8
+; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:       - Index:       0
+; CHECK-NEXT:         Name:        .rodata
+; CHECK-NEXT:       - Index:       1
+; CHECK-NEXT:         Name:        .data
 ; CHECK-NEXT: ...

test/tools/llvm-objdump/WebAssembly/relocations.test

 ; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %s -o - | llvm-objdump -r - | FileCheck %s
 
 @foo1 = hidden global i32 1, align 4
 @foo2 = hidden global i32 1, align 4
 @bar = hidden global i32* @foo2, align 4
 
 ; CHECK:      RELOCATION RECORDS FOR [DATA]:
-; CHECK-NEXT: 00000018 R_WEBASSEMBLY_MEMORY_ADDR_I32 1+0
+; CHECK-NEXT: 0000000e R_WEBASSEMBLY_MEMORY_ADDR_I32 1+0

test/tools/llvm-readobj/sections.test

 WASM-NEXT:     Type: CODE (0xA)
 WASM-NEXT:     Size: 25
 WASM-NEXT:     Offset: 123
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: DATA (0xB)
 WASM-NEXT:     Size: 19
 WASM-NEXT:     Offset: 154
+WASM-NEXT:     Segments [
+WASM-NEXT:       Segment {
+WASM-NEXT:         Size: 13
+WASM-NEXT:       }
+WASM-NEXT:     ]
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
 WASM-NEXT:     Size: 43
 WASM-NEXT:     Offset: 179
 WASM-NEXT:     Name: name
 WASM-NEXT:   }
 WASM-NEXT:   Section {

tools/llvm-readobj/WasmDumper.cpp

case wasm::WASM_SEC_CUSTOM:
       W.printString("Name", WasmSec.Name);
       if (WasmSec.Name == "linking") {
         const wasm::WasmLinkingData &LinkingData = Obj->linkingData();
         W.printNumber("DataSize", LinkingData.DataSize);
         if (LinkingData.DataAlignment)
           W.printNumber("DataAlignment", LinkingData.DataAlignment);
       }
       break;
+    case wasm::WASM_SEC_DATA: {
+      ListScope Group(W, "Segments");
+      for (const WasmSegment &Segment : Obj->dataSegments()) {
+        DictScope Group(W, "Segment");
+        if (!Segment.Data.Name.empty())
+          W.printString("Name", Segment.Data.Name);
+        W.printNumber("Size", Segment.Data.Content.size());
+      }
+      break;
+    }
     case wasm::WASM_SEC_MEMORY:
       ListScope Group(W, "Memories");
       for (const wasm::WasmLimits &Memory : Obj->memories()) {
         DictScope Group(W, "Memory");
         W.printNumber("InitialPages", Memory.Initial);
         if (Memory.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX) {
           W.printNumber("MaxPages", WasmSec.Offset);
         }

tools/obj2yaml/wasm2yaml.cpp

for (const object::SymbolRef& Sym: Obj.symbols()) {
       WasmYAML::NameEntry NameEntry;
       NameEntry.Name = *NameOrError;
       NameEntry.Index = Sym.getValue();
       NameSec->FunctionNames.push_back(NameEntry);
     }
     CustomSec = std::move(NameSec);
   } else if (WasmSec.Name == "linking") {
     std::unique_ptr<WasmYAML::LinkingSection> LinkingSec = make_unique<WasmYAML::LinkingSection>();
+    size_t Index = 0;
+    for (const object::WasmSegment &Segment : Obj.dataSegments()) {
+      if (!Segment.Data.Name.empty()) {
+        WasmYAML::NameEntry NameEntry;
+        NameEntry.Name = Segment.Data.Name;
+        NameEntry.Index = Index++;
+        LinkingSec->SegmentNames.push_back(NameEntry);
+      }
+    }
     for (const object::SymbolRef& Sym: Obj.symbols()) {
       const object::WasmSymbol Symbol = Obj.getWasmSymbol(Sym);
       if (Symbol.Flags != 0) {
         WasmYAML::SymbolInfo Info = { Symbol.Name, Symbol.Flags };
         LinkingSec->SymbolInfos.push_back(Info);
       }
     }
     LinkingSec->DataSize = Obj.linkingData().DataSize;
case wasm::WASM_SEC_CODE: {
         Function.Body = yaml::BinaryRef(Func.Body);
         CodeSec->Functions.push_back(Function);
       }
       S = std::move(CodeSec);
       break;
     }
     case wasm::WASM_SEC_DATA: {
       auto DataSec = make_unique<WasmYAML::DataSection>();
-      for (auto &Segment : Obj.dataSegments()) {
+      for (const object::WasmSegment &Segment : Obj.dataSegments()) {
         WasmYAML::DataSegment Seg;
         Seg.SectionOffset = Segment.SectionOffset;
         Seg.MemoryIndex = Segment.Data.MemoryIndex;
         Seg.Offset = Segment.Data.Offset;
         Seg.Content = yaml::BinaryRef(Segment.Data.Content);
         DataSec->Segments.push_back(Seg);
       }
       S = std::move(DataSec);

tools/yaml2obj/yaml2wasm.cpp

if (Section.SymbolInfos.size()) {
     encodeULEB128(Section.SymbolInfos.size(), SubSection.GetStream());
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolInfos) {
       writeStringRef(Info.Name, SubSection.GetStream());
       encodeULEB128(Info.Flags, SubSection.GetStream());
     }
 
     SubSection.Done();
   }
+
+  // SEGMENT_NAMES subsection
+  if (Section.SegmentNames.size()) {
+    encodeULEB128(wasm::WASM_SEGMENT_NAMES, OS);
+    encodeULEB128(Section.SegmentNames.size(), SubSection.GetStream());
+    for (const WasmYAML::NameEntry &NameEntry : Section.SegmentNames) {
+      encodeULEB128(NameEntry.Index, SubSection.GetStream());
+      writeStringRef(NameEntry.Name, SubSection.GetStream());
+    }
+    SubSection.Done();
+  }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section) {
   writeStringRef(Section.Name, OS);
   if (Section.FunctionNames.size()) {
     encodeULEB128(wasm::WASM_NAMES_FUNCTION, OS);