[WebAssembly] Allow each data segment to specify its own alignment

[sbc100]

Summary

Also, add a flags field as we will almost certainly
be needing that soon too.

[sbc100]

corresponding lld change is here: https://reviews.llvm.org/D38297

[sbc100]

@dschuff ptal

[dschuff]

Missed this yesterday, sorry.

include/llvm/BinaryFormat/Wasm.h

189

probably no need to skip enum values at this point, we don't really need any backward compatibility do we?

include/llvm/BinaryFormat/Wasm.h

struct WasmFunction {
   ArrayRef<uint8_t> Body;
 };
 
 struct WasmDataSegment {
   uint32_t MemoryIndex;
   WasmInitExpr Offset;
   ArrayRef<uint8_t> Content;
   StringRef Name;
+  uint32_t Alignment;
+  uint32_t Flags;
 };
 
 struct WasmElemSegment {
   uint32_t TableIndex;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 struct WasmRelocation {
   uint32_t Type;   // The type of the relocation.
   uint32_t Index;  // Index into function to global index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };
 
 struct WasmLinkingData {
   uint32_t DataSize;
-  uint32_t DataAlignment;
 };
 
 enum : unsigned {
   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations
   WASM_SEC_IMPORT = 2,   // Import declarations
   WASM_SEC_FUNCTION = 3, // Function declarations
   WASM_SEC_TABLE = 4,    // Indirect function table and other tables

 };
 
 // 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,
+  WASM_SEGMENT_INFO   = 0x6,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
 
 enum : unsigned {
   WASM_SYMBOL_BINDING_GLOBAL = 0x0,
   WASM_SYMBOL_BINDING_WEAK   = 0x1,
   WASM_SYMBOL_BINDING_LOCAL  = 0x2,

include/llvm/ObjectYAML/WasmYAML.h

struct DataSegment {
   yaml::BinaryRef Content;
 };
 
 struct NameEntry {
   uint32_t Index;
   StringRef Name;
 };
 
+struct SegmentInfo {
+  uint32_t Index;
+  StringRef Name;
+  uint32_t Alignment;
+  uint32_t Flags;
+};
+
 struct Signature {
   uint32_t Index;
   SignatureForm Form = wasm::WASM_TYPE_FUNC;
   std::vector<ValueType> ParamTypes;
   ValueType ReturnType;
 };
 
 struct SymbolInfo {
struct LinkingSection : CustomSection {
   LinkingSection() : CustomSection("linking") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "linking";
   }
 
   uint32_t DataSize;
-  uint32_t DataAlignment;
   std::vector<SymbolInfo> SymbolInfos;
-  std::vector<NameEntry> SegmentNames;
+  std::vector<SegmentInfo> SegmentInfos;
 };
 
 struct TypeSection : Section {
   TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_TYPE;
   }

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ElemSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Limits)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DataSegment)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Global)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Function)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::LocalDecl)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };

 template <> struct MappingTraits<WasmYAML::Relocation> {
   static void mapping(IO &IO, WasmYAML::Relocation &Relocation);
 };
 
 template <> struct MappingTraits<WasmYAML::NameEntry> {
   static void mapping(IO &IO, WasmYAML::NameEntry &NameEntry);
 };
 
+template <> struct MappingTraits<WasmYAML::SegmentInfo> {
+  static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
+};
+
 template <> struct MappingTraits<WasmYAML::LocalDecl> {
   static void mapping(IO &IO, WasmYAML::LocalDecl &LocalDecl);
 };
 
 template <> struct MappingTraits<wasm::WasmInitExpr> {
   static void mapping(IO &IO, wasm::WasmInitExpr &Expr);
 };
 

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;
+  uint32_t Alignment;
+  uint32_t Flags;
   SmallVector<char, 4> Data;
 };
 
 // A wasm import to be written into the import section.
 struct WasmImport {
   StringRef ModuleName;
   StringRef FieldName;
   unsigned Kind;
private:
   void writeDataSection(ArrayRef<WasmDataSegment> Segments);
   void writeNameSection(ArrayRef<WasmFunction> Functions,
                         ArrayRef<WasmImport> Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
       ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-      uint32_t DataAlignment,
       SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags,
       bool HasStackPointer, uint32_t StackPointerGlobal);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
 
   // Ignore overflow. LLVM allows address arithmetic to silently wrap.
   uint32_t Value = Address;
 
   return Value;
 }
 
 static void addData(SmallVectorImpl<char> &DataBytes,
-                    MCSectionWasm &DataSection, uint32_t &DataAlignment) {
-  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
-  DataAlignment = std::max(DataAlignment, DataSection.getAlignment());
+                    MCSectionWasm &DataSection) {
   DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
 
+  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
+
   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.
void WasmObjectWriter::writeDataRelocSection() {
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
     ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-    uint32_t DataAlignment,
     SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags,
     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 (SymbolFlags.size() != 0) {
     }
     endSection(SubSection);
   }
 
   if (DataSize > 0) {
     startSection(SubSection, wasm::WASM_DATA_SIZE);
     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);
+    startSection(SubSection, wasm::WASM_SEGMENT_INFO);
     encodeULEB128(Segments.size(), getStream());
-    for (const WasmDataSegment &Segment : Segments)
+    for (const WasmDataSegment &Segment : Segments) {
       writeString(Segment.Name);
+      encodeULEB128(Segment.Alignment, getStream());
+      encodeULEB128(Segment.Flags, getStream());
+    }
     endSection(SubSection);
   }
 
   endSection(Section);
 }
 
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
   assert(Symbol.isFunction());
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
   SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags;
   SmallPtrSet<const MCSymbolWasm *, 4> IsAddressTaken;
   unsigned NumFuncImports = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
-  uint32_t DataAlignment = 1;
   uint32_t StackPointerGlobal = 0;
   uint32_t DataSize = 0;
   bool HasStackPointer = false;
 
   // Populate the IsAddressTaken set.
   for (const WasmRelocationEntry &RelEntry : CodeRelocations) {
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
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);
+    addData(Segment.Data, Section);
+    Segment.Alignment = Section.getAlignment();
+    Segment.Flags = 0;
     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.
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(DataSegments, DataSize, DataAlignment,
-                              SymbolFlags, HasStackPointer, StackPointerGlobal);
+  writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
+                              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

return make_error<StringError>("Zero length section",
                                    object_error::parse_failed);
   Section.Content = ArrayRef<uint8_t>(Ptr, Size);
   Ptr += Size;
   return Error::success();
 }
 
 WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
     : ObjectFile(Binary::ID_Wasm, Buffer) {
-  LinkingData.DataAlignment = 0;
   LinkingData.DataSize = 0;
 
   ErrorAsOutParameter ErrAsOutParam(&Err);
   Header.Magic = getData().substr(0, 4);
   if (Header.Magic != StringRef("\0asm", 4)) {
     Err = make_error<StringError>("Bad magic number",
                                   object_error::parse_failed);
     return;
case wasm::WASM_SYMBOL_INFO: {
                      << Symbols[SymIndex].Name << " exptected:"
                      << Symbol << " flags: " << Flags << "\n");
       }
       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: {
+    case wasm::WASM_SEGMENT_INFO: {
       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++)
+      for (uint32_t i = 0; i < Count; i++) {
         DataSegments[i].Data.Name = readString(Ptr);
+        DataSegments[i].Data.Alignment = readVaruint32(Ptr);
+        DataSegments[i].Data.Flags = readVaruint32(Ptr);
+      }
       break;
     }
     case wasm::WASM_STACK_POINTER:
     default:
       Ptr += Size;
       break;
     }
     if (Ptr != SubSectionEnd)
Error WasmObjectFile::parseDataSection(const uint8_t *Ptr, const uint8_t *End) {
   DataSegments.reserve(Count);
   while (Count--) {
     WasmSegment Segment;
     Segment.Data.MemoryIndex = readVaruint32(Ptr);
     if (Error Err = readInitExpr(Segment.Data.Offset, Ptr))
       return Err;
     uint32_t Size = readVaruint32(Ptr);
     Segment.Data.Content = ArrayRef<uint8_t>(Ptr, Size);
+    Segment.Data.Alignment = 0;
+    Segment.Data.Flags = 0;
     Segment.SectionOffset = Ptr - Start;
     Ptr += Size;
     DataSegments.push_back(Segment);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Data section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();

lib/ObjectYAML/WasmYAML.cpp

static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
 }
 
 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);
+  IO.mapOptional("SegmentInfo", Section.SegmentInfos);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::CustomSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("Payload", Section.Payload);
 }
 

 }
 
 void MappingTraits<WasmYAML::NameEntry>::mapping(
     IO &IO, WasmYAML::NameEntry &NameEntry) {
   IO.mapRequired("Index", NameEntry.Index);
   IO.mapRequired("Name", NameEntry.Name);
 }
 
+void MappingTraits<WasmYAML::SegmentInfo>::mapping(
+    IO &IO, WasmYAML::SegmentInfo &SegmentInfo) {
+  IO.mapRequired("Index", SegmentInfo.Index);
+  IO.mapRequired("Name", SegmentInfo.Name);
+  IO.mapRequired("Alignment", SegmentInfo.Alignment);
+  IO.mapRequired("Flags", SegmentInfo.Flags);
+}
+
 void MappingTraits<WasmYAML::LocalDecl>::mapping(
     IO &IO, WasmYAML::LocalDecl &LocalDecl) {
   IO.mapRequired("Type", LocalDecl.Type);
   IO.mapRequired("Count", LocalDecl.Count);
 }
 
 void MappingTraits<WasmYAML::Limits>::mapping(IO &IO,
                                               WasmYAML::Limits &Limits) {

test/MC/WebAssembly/array-fill.ll

 @gBd = hidden global [2 x %struct.bd] [%struct.bd { i8 1 }, %struct.bd { i8 2 }], align 1
 
 ; 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:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
+; CHECK-NEXT:         Alignment:       1
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT: ...

test/MC/WebAssembly/bss.ll

 ; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o - | obj2yaml | FileCheck %s
 
 @g0 = global i8* null, align 4
 
 ; CHECK:        - Type:            DATA
 ; 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:         '00000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        4
-; CHECK-NEXT:     DataAlignment:   4
-; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .bss.g0
+; CHECK-NEXT:         Alignment:       4
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT: ...

test/MC/WebAssembly/explicit-sections.ll

 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '08000000'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        28
-; CHECK-NEXT:     DataAlignment:   8
-; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global0
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .sec1
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .sec2
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT: ...

test/MC/WebAssembly/unnamed-data.ll

 ; CHECK-NEXT:         MemoryIndex:     0
 ; 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:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            .L.str1
 ; CHECK-NEXT:         Flags:           2
 ; CHECK-NEXT:       - Name:            .L.str2
 ; CHECK-NEXT:         Flags:           2
-; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:       0
 ; CHECK-NEXT:         Name:        .rodata..L.str1
+; CHECK-NEXT:         Alignment:   1
+; CHECK-NEXT:         Flags:       0
 ; CHECK-NEXT:       - Index:       1
 ; CHECK-NEXT:         Name:        .rodata..L.str2
+; CHECK-NEXT:         Alignment:   1
+; CHECK-NEXT:         Flags:       0
 ; CHECK-NEXT:       - Index:       2
 ; CHECK-NEXT:         Name:        .data.a
+; CHECK-NEXT:         Alignment:   8
+; CHECK-NEXT:         Flags:       0
 ; CHECK-NEXT:       - Index:       3
 ; CHECK-NEXT:         Name:        .data.b
+; CHECK-NEXT:         Alignment:   8
+; CHECK-NEXT:         Flags:       0
 ; CHECK_NEXT:   ...

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        12
-; CHECK-NEXT:     DataAlignment:   8
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT:       - Name:            bar_alias
 ; CHECK-NEXT:         Flags:           1
-; CHECK-NEXT:     SegmentNames:    
+; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.bar
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.bar_alias_address
+; CHECK-NEXT:         Alignment:       8
+; CHECK-NEXT:         Flags:           0
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
 ; CHECK-SYMS-NEXT: 00000000 g     F name  call_alias
 ; CHECK-SYMS-NEXT: 00000001 g     F name  foo
 ; CHECK-SYMS-NEXT: 00000000 g     F EXPORT  call_alias
 ; CHECK-SYMS-NEXT: 00000001 g     F EXPORT  foo
 ; CHECK-SYMS-NEXT: 00000000 g       EXPORT  bar
 ; CHECK-SYMS-NEXT: 00000008 g       EXPORT  bar_alias_address
 ; CHECK-SYMS-NEXT: 00000001 gw    F EXPORT  foo_alias
 ; CHECK-SYMS-NEXT: 00000000 gw      EXPORT  bar_alias

test/MC/WebAssembly/weak.ll

 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
-; CHECK-NEXT:     DataAlignment:   0
 ; CHECK-NEXT:     SymbolInfo:      
 ; CHECK-NEXT:       - Name:            weak_external_data
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT:       - Name:            weak_function
 ; CHECK-NEXT:         Flags:           1
 ; CHECK-NEXT: ...

test/ObjectYAML/wasm/weak_symbols.yaml

Exports:
         Kind:            FUNCTION
         Index:           1
       - Name:            global_export
         Kind:            GLOBAL
         Index:           0
   - Type:            CUSTOM
     Name:            linking
     DataSize:        10
-    DataAlignment:   2
     SymbolInfo:
       - Name:            function_export
         Flags:           1
       - Name:            global_export
         Flags:           1
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            EXPORT
 # CHECK:     Exports:         
 # CHECK:       - Name:            function_export
 # CHECK:         Kind:            FUNCTION
 # CHECK:         Index:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Kind:            GLOBAL
 # CHECK:         Index:           0
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            linking
 # CHECK:     DataSize:        10
-# CHECK:     DataAlignment:   2
 # CHECK:     SymbolInfo:
 # CHECK:       - Name:            function_export
 # CHECK:         Flags:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Flags:           1

test/tools/llvm-nm/wasm/exports.yaml

Exports:
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            bar
         Kind:            GLOBAL
         Index:           0x00000003
   - Type:            CUSTOM
     Name:            "linking"
     DataSize:        0
-    DataAlignment:   0
 
 # CHECK:      00000400 D bar
 # CHECK-NEXT:          U fimport
 # CHECK-NEXT: 00000004 T foo
 # CHECK-NEXT:          U gimport

test/tools/llvm-nm/wasm/imports.yaml

Imports:
       - Module:          env
         Field:           bar
         Kind:            GLOBAL
         GlobalType:      I32
         GlobalMutable:   false
   - Type:            CUSTOM
     Name:            "linking"
     DataSize:        0
-    DataAlignment:   0
 
 # CHECK:    U bar
 # CHECK:    U foo

test/tools/llvm-nm/wasm/weak-symbols.yaml

Exports:
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            weak_global_data
         Kind:            GLOBAL
         Index:           0x00000003
   - Type:            CUSTOM
     Name:            linking
     DataSize:        0
-    DataAlignment:   2
     SymbolInfo:
       - Name:            weak_global_func
         Flags:           1
       - Name:            weak_global_data
         Flags:           1
       - Name:            weak_import_func
         Flags:           1
       - Name:            weak_import_data
         Flags:           1
 
 # CHECK: 00000400 W weak_global_data
 # CHECK: 00000004 W weak_global_func
 # CHECK:          w weak_import_data
 # CHECK:          w weak_import_func

test/tools/llvm-readobj/sections.test

 WASM-NEXT:     Name: reloc.CODE
 WASM-NEXT:   }
 WASM-NEXT:   Section {
 WASM-NEXT:     Type: CUSTOM (0x0)
 WASM-NEXT:     Size: 22
 WASM-NEXT:     Offset: 257
 WASM-NEXT:     Name: linking
 WASM-NEXT:     DataSize: 13
-WASM-NEXT:     DataAlignment: 1
 WASM-NEXT:   }
 WASM-NEXT: ]

tools/llvm-readobj/WasmDumper.cpp

for (const SectionRef &Section : Obj->sections()) {
     W.printNumber("Size", static_cast<uint64_t>(WasmSec.Content.size()));
     W.printNumber("Offset", WasmSec.Offset);
     switch (WasmSec.Type) {
     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()) {
         const wasm::WasmDataSegment& Seg = Segment.Data;
         DictScope Group(W, "Segment");
         if (!Seg.Name.empty())

tools/obj2yaml/wasm2yaml.cpp

for (const object::SymbolRef& Sym: Obj.symbols()) {
       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);
+        WasmYAML::SegmentInfo SegmentInfo;
+        SegmentInfo.Name = Segment.Data.Name;
+        SegmentInfo.Index = Index;
+        SegmentInfo.Alignment = Segment.Data.Alignment;
+        SegmentInfo.Flags = Segment.Data.Flags;
+        LinkingSec->SegmentInfos.push_back(SegmentInfo);
       }
       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;
-    LinkingSec->DataAlignment = Obj.linkingData().DataAlignment;
     CustomSec = std::move(LinkingSec);
   } else {
     CustomSec = make_unique<WasmYAML::CustomSection>(WasmSec.Name);
   }
   CustomSec->Payload = yaml::BinaryRef(WasmSec.Content);
   return CustomSec;
 }
 

tools/yaml2obj/yaml2wasm.cpp

int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section) {
 
   SubSectionWriter SubSection(OS);
 
   // DATA_SIZE subsection
   encodeULEB128(wasm::WASM_DATA_SIZE, OS);
   encodeULEB128(Section.DataSize, SubSection.GetStream());
   SubSection.Done();
 
-  // DATA_ALIGNMENT subsection
-  encodeULEB128(wasm::WASM_DATA_ALIGNMENT, OS);
-  encodeULEB128(Section.DataAlignment, SubSection.GetStream());
-  SubSection.Done();
-
   // SYMBOL_INFO subsection
   if (Section.SymbolInfos.size()) {
     encodeULEB128(wasm::WASM_SYMBOL_INFO, OS);
 
     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());
+  if (Section.SegmentInfos.size()) {
+    encodeULEB128(wasm::WASM_SEGMENT_INFO, OS);
+    encodeULEB128(Section.SegmentInfos.size(), SubSection.GetStream());
+    for (const WasmYAML::SegmentInfo &SegmentInfo : Section.SegmentInfos) {
+      encodeULEB128(SegmentInfo.Index, SubSection.GetStream());
+      writeStringRef(SegmentInfo.Name, SubSection.GetStream());
+      encodeULEB128(SegmentInfo.Alignment, SubSection.GetStream());
+      encodeULEB128(SegmentInfo.Flags, SubSection.GetStream());
     }
     SubSection.Done();
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section) {
   writeStringRef(Section.Name, OS);