[WebAssembly] Add support for naming wasm data segments

[sbc100]

Summary

Add adds support for naming data segments. This is useful
useful linkers so that they can merge similar sections.

[sbc100]

• fix

[sbc100]

fix test

[sbc100]

• don't use const ArrayRef
• fix test

[sbc100]

• cleanup tests

[dschuff]

So are we going to say that the mere existence of segment names tells the linker it should merge them as though they were separate data sections? (or, is there any other possible use?) Is there other potential per-MCSection metadata we'd want that would make this metadata end up more generic?

[sbc100]

Yes, there is the potential that we might need more metadata down the road (type, flags, etc) but right now I think name is enough for to get init_array and fini_array working.

WRT to merging I plan to follow the same rules as the ELF version of lld. I'm hoping that name will be enough for me to do this, but I guess I might need type/flags down the road. However this change should be enough to get init_array / fini_array working which is my immediate goal.

[sbc100]

• add bss test case

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/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/MC/WasmObjectWriter.cpp

 };
 
 // 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;
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);
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];
 }
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   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.
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);
 }
 

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/unnamed-data.ll

 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '06000000'
 ; 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-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);
+      }
+      Index++;
+    }
     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);