[WebAssembly][yaml2obj][obj2yaml] Elem sections for nonzero tables

[wingo]

Summary

With reference types, tables can have non-zero table numbers. This
commit adds support for element sections against these tables.

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

937

inline comments from @sbc100, from https://reviews.llvm.org/D92321?id=323966#inline-917851:

Paging this back in -- this code was not dead. See the definition for WASM_ELEM_SEGMENT_HAS_ELEM_KIND. I have restored it here. WDYT?

Oh I see.. WASM_ELEM_SEGMENT_HAS_ELEM_KIND is defined as ~SOME_OTHER_FLAG.. that seem odd at best. Perhaps better write to little helper function elemSegmentNeedsElemKind() rather than trying to make that part of the enum? Otherwise folks will think that WASM_ELEM_SEGMENT_HAS_ELEM_KIND is just another flag they can | together. Either that or maybe add MASK to its name and take it out of the enum with the others.

It looks like WASM_ELEM_SEGMENT_HAS_ELEM_KIND is basically PASSIVE | HAS_TABLE_NUMBER ... maybe its more clear to just write that out here?

[wingo]

Add _MASK to HAS_ELEM_KIND name

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

937

Given that we need the logic in 4 different files, it seemed like defining the mask in a central place would be a good idea. You're right though that as it was, you could get confused and think that (WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER & WASM_ELEMENT_SEGMENT_HAS_ELEM_KIND) == 0. I changed the name therefore to WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND; wdyt?

There's no accounting for taste, obviously, and if you have a strong preference here, I am very happy to adapt.

I think all the other inline comments from D92321 have been addressed in this patch, fwiw.

[sbc100]

lgtm!

llvm/include/llvm/BinaryFormat/Wasm.h

316

Do you think this should outside the enum perhaps?

llvm/lib/MC/WasmObjectWriter.cpp

919

It looks like we pass IndirectFunctionTable just to get the table nunber.

Would it make sense to instead change the signature of this functions to:

void WasmObjectWriter::writeElemSection(uint32_t TableNumber, ArrayRef<uint32_t> TableElems)

And then it can be re-used later once we support different tables? Or maybe that be part of the followup?

lgtm which ever way you think makes sense.

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

919

Yeah that's right. Would work fine to pass a table number, only except that if TableElems is empty, it could be that there's no function table symbol. Once we start having different / other tables, we may want to split things; there may be multiple segments against different tables, for example. If OK with you, will reserve any needed refactors for a followup.

[wingo]

llvm/include/llvm/BinaryFormat/Wasm.h

316

fixed when pushed as

const unsigned WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND = 0x3;

llvm/include/llvm/BinaryFormat/Wasm.h

struct WasmDataSegment {
   ArrayRef<uint8_t> Content;
   StringRef Name; // from the "segment info" section
   uint32_t Alignment;
   uint32_t LinkerFlags;
   uint32_t Comdat; // from the "comdat info" section
 };
 
 struct WasmElemSegment {
-  uint32_t TableIndex;
+  uint32_t Flags;
+  uint32_t TableNumber;
+  uint8_t ElemKind;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 // Represents the location of a Wasm data symbol within a WasmDataSegment, as
 // the index of the segment, and the offset and size within the segment.
 struct WasmDataReference {
   uint32_t Segment;
enum : unsigned {
   WASM_LIMITS_FLAG_IS_64 = 0x4,
 };
 
 enum : unsigned {
   WASM_DATA_SEGMENT_IS_PASSIVE = 0x01,
   WASM_DATA_SEGMENT_HAS_MEMINDEX = 0x02,
 };
 
+enum : unsigned {
+  WASM_ELEM_SEGMENT_IS_PASSIVE = 0x01,
+  WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER = 0x02,
+  WASM_ELEM_SEGMENT_HAS_INIT_EXPRS = 0x04,
+  WASM_ELEM_SEGMENT_HAS_ELEM_KIND = ~WASM_ELEM_SEGMENT_HAS_INIT_EXPRS
+};
+
 // Feature policy prefixes used in the custom "target_features" section
 enum : uint8_t {
   WASM_FEATURE_PREFIX_USED = '+',
   WASM_FEATURE_PREFIX_REQUIRED = '=',
   WASM_FEATURE_PREFIX_DISALLOWED = '-',
 };
 
 // Kind codes used in the custom "name" section

llvm/include/llvm/Object/Wasm.h

struct ReadContext {
     const uint8_t *Ptr;
     const uint8_t *End;
   };
 
 private:
   bool isValidFunctionIndex(uint32_t Index) const;
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
-  bool isValidTableIndex(uint32_t Index) const;
+  bool isValidTableNumber(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
-  bool isDefinedTableIndex(uint32_t Index) const;
+  bool isDefinedTableNumber(uint32_t Index) const;
   bool isValidEventIndex(uint32_t Index) const;
   bool isDefinedEventIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
   bool isValidTableSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
   bool isValidEventSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
   bool isValidSectionSymbol(uint32_t Index) const;

llvm/include/llvm/ObjectYAML/WasmYAML.h

 
 struct Export {
   StringRef Name;
   ExportKind Kind;
   uint32_t Index;
 };
 
 struct ElemSegment {
-  uint32_t TableIndex;
+  uint32_t Flags;
+  uint32_t TableNumber;
+  ValueType ElemKind;
   wasm::WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 struct Global {
   uint32_t Index;
   ValueType Type;
   bool Mutable;

llvm/lib/MC/WasmObjectWriter.cpp

private:
 
   void writeValueType(wasm::ValType Ty) { W->OS << static_cast<char>(Ty); }
 
   void writeTypeSection(ArrayRef<wasm::WasmSignature> Signatures);
   void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint64_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
-  void writeElemSection(ArrayRef<uint32_t> TableElems);
+  void writeElemSection(const MCSymbolWasm *IndirectFunctionTable,
+                        ArrayRef<uint32_t> TableElems);
   void writeDataCountSection();
   uint32_t writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                             ArrayRef<WasmFunction> Functions);
   uint32_t writeDataSection(const MCAsmLayout &Layout);
   void writeEventSection(ArrayRef<wasm::WasmEventType> Events);
   void writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals);
   void writeTableSection(ArrayRef<wasm::WasmTable> Tables);
   void writeRelocSection(uint32_t SectionIndex, StringRef Name,
for (const wasm::WasmExport &Export : Exports) {
     writeString(Export.Name);
     W->OS << char(Export.Kind);
     encodeULEB128(Export.Index, W->OS);
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
+void WasmObjectWriter::writeElemSection(
+    const MCSymbolWasm *IndirectFunctionTable, ArrayRef<uint32_t> TableElems) {
   if (TableElems.empty())
     return;
 
+  assert(IndirectFunctionTable);
+
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_ELEM);
 
   encodeULEB128(1, W->OS); // number of "segments"
-  encodeULEB128(0, W->OS); // the table index
+
+  assert(WasmIndices.count(IndirectFunctionTable));
+  uint32_t TableNumber = WasmIndices.find(IndirectFunctionTable)->second;
+  uint32_t Flags = 0;
+  if (TableNumber)
+    Flags |= wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER;
+  encodeULEB128(Flags, W->OS);
+  if (Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
+    encodeULEB128(TableNumber, W->OS); // the table number
 
   // init expr for starting offset
   W->OS << char(wasm::WASM_OPCODE_I32_CONST);
   encodeSLEB128(InitialTableOffset, W->OS);
   W->OS << char(wasm::WASM_OPCODE_END);
 
+  if (Flags & wasm::WASM_ELEM_SEGMENT_HAS_ELEM_KIND) {
+    // We only write active function table initializers, for which the elem kind
+    // is specified to be written as 0x00 and interpreted to mean "funcref".
+    const uint8_t ElemKind = 0;
+    W->OS << ElemKind;
+  }
+
   encodeULEB128(TableElems.size(), W->OS);
   for (uint32_t Elem : TableElems)
     encodeULEB128(Elem, W->OS);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeDataCountSection() {
if (Mode != DwoMode::DwoOnly) {
     writeTypeSection(Signatures);
     writeImportSection(Imports, DataSize, TableElems.size());
     writeFunctionSection(Functions);
     writeTableSection(Tables);
     // Skip the "memory" section; we import the memory instead.
     writeEventSection(Events);
     writeGlobalSection(Globals);
     writeExportSection(Exports);
-    writeElemSection(TableElems);
+    const MCSymbol *IndirectFunctionTable =
+        Asm.getContext().lookupSymbol("__indirect_function_table");
+    writeElemSection(cast_or_null<const MCSymbolWasm>(IndirectFunctionTable),
+                     TableElems);
     writeDataCountSection();
 
     CodeSectionIndex = writeCodeSection(Asm, Layout, Functions);
     DataSectionIndex = writeDataSection(Layout);
   }
 
   // The Sections in the COMDAT list have placeholder indices (their index among
   // custom sections, rather than among all sections). Fix them up here.

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_SYMBOL_TYPE_GLOBAL:
         if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_TABLE:
       Info.ElementIndex = readVaruint32(Ctx);
-      if (!isValidTableIndex(Info.ElementIndex) ||
-          IsDefined != isDefinedTableIndex(Info.ElementIndex))
+      if (!isValidTableNumber(Info.ElementIndex) ||
+          IsDefined != isDefinedTableNumber(Info.ElementIndex))
         return make_error<GenericBinaryError>("invalid table symbol index",
                                               object_error::parse_failed);
       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
                             wasm::WASM_SYMBOL_BINDING_WEAK)
         return make_error<GenericBinaryError>("undefined weak table symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
-        unsigned TableIndex = Info.ElementIndex - NumImportedTables;
-        wasm::WasmTable &Table = Tables[TableIndex];
+        unsigned TableNumber = Info.ElementIndex - NumImportedTables;
+        wasm::WasmTable &Table = Tables[TableNumber];
         TableType = &Table.Type;
         if (Table.SymbolName.empty())
           Table.SymbolName = Info.Name;
       } else {
         wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
           Info.ImportName = Import.Field;

 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
 }
 
 bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
   return Index < NumImportedGlobals + Globals.size();
 }
 
-bool WasmObjectFile::isValidTableIndex(uint32_t Index) const {
+bool WasmObjectFile::isValidTableNumber(uint32_t Index) const {
   return Index < NumImportedTables + Tables.size();
 }
 
 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
 }
 
-bool WasmObjectFile::isDefinedTableIndex(uint32_t Index) const {
-  return Index >= NumImportedTables && isValidTableIndex(Index);
+bool WasmObjectFile::isDefinedTableNumber(uint32_t Index) const {
+  return Index >= NumImportedTables && isValidTableNumber(Index);
 }
 
 bool WasmObjectFile::isValidEventIndex(uint32_t Index) const {
   return Index < NumImportedEvents + Events.size();
 }
 
 bool WasmObjectFile::isDefinedEventIndex(uint32_t Index) const {
   return Index >= NumImportedEvents && isValidEventIndex(Index);
Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
   return Error::success();
 }
 
 Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   ElemSegments.reserve(Count);
   while (Count--) {
     wasm::WasmElemSegment Segment;
-    Segment.TableIndex = readVaruint32(Ctx);
-    if (Segment.TableIndex != 0) {
-      return make_error<GenericBinaryError>("invalid TableIndex",
+    Segment.Flags = readVaruint32(Ctx);
+
+    uint32_t SupportedFlags = wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER |
+                              wasm::WASM_ELEM_SEGMENT_IS_PASSIVE |
+                              wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS;
+    if (Segment.Flags & ~SupportedFlags)
+      return make_error<GenericBinaryError>(
+          "Unsupported flags for element segment", object_error::parse_failed);
+
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
+      Segment.TableNumber = readVaruint32(Ctx);
+    else
+      Segment.TableNumber = 0;
+    if (!isValidTableNumber(Segment.TableNumber))
+      return make_error<GenericBinaryError>("invalid TableNumber",
                                             object_error::parse_failed);
-    }
+
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_IS_PASSIVE) {
+      Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
+      Segment.Offset.Value.Int32 = 0;
+    } else {
       if (Error Err = readInitExpr(Segment.Offset, Ctx))
         return Err;
+    }
+
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_ELEM_KIND) {
+      Segment.ElemKind = readUint8(Ctx);
+      if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS) {
+        if (Segment.ElemKind != uint8_t(wasm::ValType::FUNCREF) &&
+            Segment.ElemKind != uint8_t(wasm::ValType::EXTERNREF)) {
+          return make_error<GenericBinaryError>("invalid reference type",
+                                                object_error::parse_failed);
+        }
+      } else {
+        if (Segment.ElemKind != 0)
+          return make_error<GenericBinaryError>("invalid elemtype",
+                                                object_error::parse_failed);
+        Segment.ElemKind = uint8_t(wasm::ValType::FUNCREF);
+      }
+    } else {
+      Segment.ElemKind = uint8_t(wasm::ValType::FUNCREF);
+    }
+
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS)
+      return make_error<GenericBinaryError>(
+          "elem segment init expressions not yet implemented",
+          object_error::parse_failed);
+
     uint32_t NumElems = readVaruint32(Ctx);
     while (NumElems--) {
       Segment.Functions.push_back(readVaruint32(Ctx));
     }
     ElemSegments.push_back(Segment);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("elem section ended prematurely",

llvm/lib/ObjectYAML/WasmEmitter.cpp

for (auto &Global : Section.Globals) {
     writeInitExpr(OS, Global.InitExpr);
   }
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::ElemSection &Section) {
   encodeULEB128(Section.Segments.size(), OS);
   for (auto &Segment : Section.Segments) {
-    encodeULEB128(Segment.TableIndex, OS);
+    encodeULEB128(Segment.Flags, OS);
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
+      encodeULEB128(Segment.TableNumber, OS);
+
     writeInitExpr(OS, Segment.Offset);
 
+    if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_ELEM_KIND) {
+      // We only support active function table initializers, for which the elem
+      // kind is specified to be written as 0x00 and interpreted to mean
+      // "funcref".
+      if (Segment.ElemKind != uint32_t(wasm::ValType::FUNCREF)) {
+        reportError("unexpected elemkind: " + Twine(Segment.ElemKind));
+        return;
+      }
+      const uint8_t ElemKind = 0;
+      writeUint8(OS, ElemKind);
+    }
+
     encodeULEB128(Segment.Functions.size(), OS);
     for (auto &Function : Segment.Functions)
       encodeULEB128(Function, OS);
   }
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::CodeSection &Section) {

llvm/lib/ObjectYAML/WasmYAML.cpp

if (!IO.outputting() || Limits.Flags)
     IO.mapOptional("Flags", Limits.Flags);
   IO.mapRequired("Initial", Limits.Initial);
   if (!IO.outputting() || Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
     IO.mapOptional("Maximum", Limits.Maximum);
 }
 
 void MappingTraits<WasmYAML::ElemSegment>::mapping(
     IO &IO, WasmYAML::ElemSegment &Segment) {
+  if (!IO.outputting() || Segment.Flags)
+    IO.mapOptional("Flags", Segment.Flags);
+  if (!IO.outputting() ||
+      Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
+    IO.mapOptional("TableNumber", Segment.TableNumber);
+  if (!IO.outputting() || Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_ELEM_KIND)
+    IO.mapOptional("ElemKind", Segment.ElemKind);
   IO.mapRequired("Offset", Segment.Offset);
   IO.mapRequired("Functions", Segment.Functions);
 }
 
 void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
                                               WasmYAML::Import &Import) {
   IO.mapRequired("Module", Import.Module);
   IO.mapRequired("Field", Import.Field);

llvm/test/ObjectYAML/wasm/multiple-tables.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+
+--- !WASM
+FileHeader:
+  Version:         0x1
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - Index:           0
+        ParamTypes:      []
+        ReturnTypes:     []
+  - Type:            IMPORT
+    Imports:
+      - Module:          env
+        Field:           table_a
+        Kind:            TABLE
+        Table:
+          Index:           0
+          ElemType:        FUNCREF
+          Limits:
+            Initial:         0x0
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0 ]
+  - Type:            TABLE
+    Tables:
+      - Index:           1
+        ElemType:        FUNCREF
+        Limits:
+          Initial:         0x0
+      - Index:           2
+        ElemType:        EXTERNREF
+        Limits:
+          Initial:         0x0
+      - Index:           3
+        ElemType:        FUNCREF
+        Limits:
+          Flags:           [ HAS_MAX ]
+          Initial:         0x3
+          Maximum:         0x3
+  - Type:            EXPORT
+    Exports:
+      - Name:            table_b
+        Kind:            TABLE
+        Index:           1
+      - Name:            table_c
+        Kind:            TABLE
+        Index:           2
+  - Type:            ELEM
+    Segments:
+      - Flags:           2
+        TableNumber:     3
+        ElemKind:        FUNCREF
+        Offset:
+          Opcode:          I32_CONST
+          Value:           1
+        Functions:       [ 0, 0 ]
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:          []
+        Body:            0B
+...
+
+#      CHECK: --- !WASM
+# CHECK-NEXT: FileHeader:
+# CHECK-NEXT:   Version:         0x1
+# CHECK-NEXT: Sections:
+# CHECK-NEXT:   - Type:            TYPE
+# CHECK-NEXT:     Signatures:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         ParamTypes:      []
+# CHECK-NEXT:         ReturnTypes:     []
+# CHECK-NEXT:   - Type:            IMPORT
+# CHECK-NEXT:     Imports:
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           table_a
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Table:
+# CHECK-NEXT:           Index:           0
+# CHECK-NEXT:           ElemType:        FUNCREF
+# CHECK-NEXT:           Limits:
+# CHECK-NEXT:             Initial:         0x0
+# CHECK-NEXT:   - Type:            FUNCTION
+# CHECK-NEXT:     FunctionTypes:   [ 0 ]
+# CHECK-NEXT:   - Type:            TABLE
+# CHECK-NEXT:     Tables:
+# CHECK-NEXT:       - Index:           1
+# CHECK-NEXT:         ElemType:        FUNCREF
+# CHECK-NEXT:         Limits:
+# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:       - Index:           2
+# CHECK-NEXT:         ElemType:        EXTERNREF
+# CHECK-NEXT:         Limits:
+# CHECK-NEXT:           Initial:         0x0
+# CHECK-NEXT:       - Index:           3
+# CHECK-NEXT:         ElemType:        FUNCREF
+# CHECK-NEXT:         Limits:
+# CHECK-NEXT:           Flags:           [ HAS_MAX ]
+# CHECK-NEXT:           Initial:         0x3
+# CHECK-NEXT:           Maximum:         0x3
+# CHECK-NEXT:   - Type:            EXPORT
+# CHECK-NEXT:     Exports:
+# CHECK-NEXT:       - Name:            table_b
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Index:           1
+# CHECK-NEXT:       - Name:            table_c
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Index:           2
+# CHECK-NEXT:   - Type:            ELEM
+# CHECK-NEXT:     Segments:
+# CHECK-NEXT:       - Flags:           2
+# CHECK-NEXT:         TableNumber:     3
+# CHECK-NEXT:         ElemKind:        FUNCREF
+# CHECK-NEXT:         Offset:
+# CHECK-NEXT:           Opcode:          I32_CONST
+# CHECK-NEXT:           Value:           1
+# CHECK-NEXT:         Functions:       [ 0, 0 ]
+# CHECK-NEXT:   - Type:            CODE
+# CHECK-NEXT:     Functions:
+# CHECK-NEXT:       - Index:           0
+# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Body:            0B
+# CHECK-NEXT: ...

llvm/tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_EXPORT: {
       }
       S = std::move(ExportSec);
       break;
     }
     case wasm::WASM_SEC_ELEM: {
       auto ElemSec = std::make_unique<WasmYAML::ElemSection>();
       for (auto &Segment : Obj.elements()) {
         WasmYAML::ElemSegment Seg;
-        Seg.TableIndex = Segment.TableIndex;
+        Seg.Flags = Segment.Flags;
+        Seg.TableNumber = Segment.TableNumber;
+        Seg.ElemKind = Segment.ElemKind;
         Seg.Offset = Segment.Offset;
         append_range(Seg.Functions, Segment.Functions);
         ElemSec->Segments.push_back(Seg);
       }
       S = std::move(ElemSec);
       break;
     }
     case wasm::WASM_SEC_CODE: {