[WebAssembly] Second phase of implementing extended const proposal.

[sbc100]

Summary

This change continues to lay the ground work for supporting extended
const expressions in the linker.

The included test covers object file reading and writing and the YAML
representation.

I have a followup PR that actually adds support for using these extended
expression in the linker.

[sbc100]

• test

[dschuff]

I assume these llvm_unreachables your're adding in this CL are the places that will be filled in in subsequent CLs?

llvm/include/llvm/ObjectYAML/WasmYAML.h

67

Should these be a union?
I wonder when we can go to C++17 variant...

llvm/lib/MC/WasmObjectWriter.cpp

935

llvm/lib/Object/WasmObjectFile.cpp

200

this is a bit confusing. If there's just a const/global.get/ref.null followed by an end, it's MVP, otherwise it's extended. But can there be 2 consts in a row? Seems like that would also be accepted here? and then line 208 would read a 3rd opcode?

[sbc100]

In D121349#3373299, @dschuff wrote:

I assume these llvm_unreachables your're adding in this CL are the places that will be filled in in subsequent CLs?

Yup.. they represent places where we don't currently handle extended const.. but we will do soon.

llvm/lib/Object/WasmObjectFile.cpp

200

Line 206 resets the the read pointer back to the start of the init expr.

Its kind of sad we have to actually parse of the initexpr here. Turns out that because the initexpr doesn't encode its own length (unlike a function) it cannot be skipped over which means that is not possible to write a file decoder that doesn't also have an instruction decodeer :(

[sbc100]

• feedback

[sbc100]

Follow up actually add support in lld: https://reviews.llvm.org/D121420

[dschuff]

llvm/lib/Object/WasmObjectFile.cpp

200

I guess you can skip over the whole section, but not each individual init expr. Is there any use case for wanting to skip over or avoid parsing some subset of initexprs? Even our file decoders in LLVM still parsed the const exprs of MVP.
... I guess this file itself is an example of where we want to know the location/size of the initexpr but don't care about evaluating it.
I wonder if it would be worth adding an extra byte to every initexpr to encode the size. Seems like a lot when each expr is still just a few bytes.

211

This loop could at least be simplified if we just used readULEB128 instead of all these typed versions e.g. readVarint32 since we aren't using the value and maybe don't care if the encoded value overflows.

[sbc100]

llvm/lib/Object/WasmObjectFile.cpp

200

I actually already opened a bug to discuss the possibility of adding a size so we could avoid writing and instruction decoder here: https://github.com/WebAssembly/design/issues/1443.

I'm guessing it would be tricky to add at this point.

[sbc100]

• feedback

[dschuff]

This code is fine as a reflection of the current state of the proposal though.

llvm/lib/Object/WasmObjectFile.cpp

200

It's certainly not too late to change the extended-const proposal. We can follow up there.

llvm/test/ObjectYAML/wasm/extended_const_expressions.yaml

20

Maybe it's worth checking an invalid constexpr (to test that we either do or don't care about validity in this particular code)?

[saugustine]

This patch triggers a bunch of uninitialized memory under msan errors when running llvm-project/lld/test/wasm:data-layout.s (and several others) as below:

exit status 2
==1915==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x55e0ff9ca683 in (anonymous namespace)::WasmDumper::dump() /llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:374:13
    #1 0x55e0ff9c1b87 in wasm2yaml(llvm::raw_ostream&, llvm::object::WasmObjectFile const&) llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:411:50
    #2 0x55e0ff9be3c9 in dumpObject llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:40:29
    #3 0x55e0ff9be3c9 in dumpInput llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:67:12
    #4 0x55e0ff9be3c9 in main llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:89:19
    #5 0x7f7a5befc8d2 in __libc_start_main (/usr/grte/v5/lib64/libc.so.6+0x628d2) (BuildId: 7cfed7708e5ab7fcb286b373de21ee76)
    #6 0x55e0ff798429 in _start /usr/grte/v5/debug-src/src/csu/../sysdeps/x86_64/start.S:120

SUMMARY: MemorySanitizer: use-of-uninitialized-value llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:374:13 in (anonymous namespace)::WasmDumper::dump()
Exiting
FileCheck error: '<stdin>' is empty.
FileCheck command line:  llvm-project/llvm/FileCheck --allow-unused-prefixes llvm-project/lld/test/wasm/data-layout.s -check-prefix=CHECK-SHARED

[sbc100]

In D121349#3380735, @saugustine wrote:

This patch triggers a bunch of uninitialized memory under msan errors when running llvm-project/lld/test/wasm:data-layout.s (and several others) as below:

exit status 2
==1915==WARNING: MemorySanitizer: use-of-uninitialized-value
    #0 0x55e0ff9ca683 in (anonymous namespace)::WasmDumper::dump() /llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:374:13
    #1 0x55e0ff9c1b87 in wasm2yaml(llvm::raw_ostream&, llvm::object::WasmObjectFile const&) llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:411:50
    #2 0x55e0ff9be3c9 in dumpObject llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:40:29
    #3 0x55e0ff9be3c9 in dumpInput llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:67:12
    #4 0x55e0ff9be3c9 in main llvm-project/llvm/tools/obj2yaml/obj2yaml.cpp:89:19
    #5 0x7f7a5befc8d2 in __libc_start_main (/usr/grte/v5/lib64/libc.so.6+0x628d2) (BuildId: 7cfed7708e5ab7fcb286b373de21ee76)
    #6 0x55e0ff798429 in _start /usr/grte/v5/debug-src/src/csu/../sysdeps/x86_64/start.S:120

SUMMARY: MemorySanitizer: use-of-uninitialized-value llvm-project/llvm/tools/obj2yaml/wasm2yaml.cpp:374:13 in (anonymous namespace)::WasmDumper::dump()
Exiting
FileCheck error: '<stdin>' is empty.
FileCheck command line:  llvm-project/llvm/FileCheck --allow-unused-prefixes llvm-project/lld/test/wasm/data-layout.s -check-prefix=CHECK-SHARED

Thanks, investigating.

[sbc100]

Attempted fix for ASAN issue: https://github.com/llvm/llvm-project/commit/2481adb59cb63c90879f4537ad36339da3ad61a6

I was unable to repro the ASAN issue locally, so please let me know if this fix is effective. I've fairly confident it will me.

lld/wasm/InputElement.h

 
 protected:
   StringRef name;
   llvm::Optional<uint32_t> assignedIndex;
 };
 
 inline WasmInitExpr intConst(uint64_t value, bool is64) {
   WasmInitExpr ie;
+  ie.Extended = false;
   if (is64) {
-    ie.Opcode = llvm::wasm::WASM_OPCODE_I64_CONST;
-    ie.Value.Int64 = static_cast<int64_t>(value);
+    ie.Inst.Opcode = llvm::wasm::WASM_OPCODE_I64_CONST;
+    ie.Inst.Value.Int64 = static_cast<int64_t>(value);
   } else {
-    ie.Opcode = llvm::wasm::WASM_OPCODE_I32_CONST;
-    ie.Value.Int32 = static_cast<int32_t>(value);
+    ie.Inst.Opcode = llvm::wasm::WASM_OPCODE_I32_CONST;
+    ie.Inst.Value.Int32 = static_cast<int32_t>(value);
   }
   return ie;
 }
 
 class InputGlobal : public InputElement {
 public:
   InputGlobal(const WasmGlobal &g, ObjFile *f)
       : InputElement(g.SymbolName, f), type(g.Type), initExpr(g.InitExpr) {}

lld/wasm/InputFiles.cpp

void ObjFile::parse(bool ignoreComdats) {
   // Build up a map of function indices to table indices for use when
   // verifying the existing table index relocations
   uint32_t totalFunctions =
       wasmObj->getNumImportedFunctions() + wasmObj->functions().size();
   tableEntriesRel.resize(totalFunctions);
   tableEntries.resize(totalFunctions);
   for (const WasmElemSegment &seg : wasmObj->elements()) {
     int64_t offset;
-    if (seg.Offset.Opcode == WASM_OPCODE_I32_CONST)
-      offset = seg.Offset.Value.Int32;
-    else if (seg.Offset.Opcode == WASM_OPCODE_I64_CONST)
-      offset = seg.Offset.Value.Int64;
+    if (seg.Offset.Extended)
+      fatal(toString(this) + ": extended init exprs not supported");
+    else if (seg.Offset.Inst.Opcode == WASM_OPCODE_I32_CONST)
+      offset = seg.Offset.Inst.Value.Int32;
+    else if (seg.Offset.Inst.Opcode == WASM_OPCODE_I64_CONST)
+      offset = seg.Offset.Inst.Value.Int64;
     else
       fatal(toString(this) + ": invalid table elements");
     for (size_t index = 0; index < seg.Functions.size(); index++) {
       auto functionIndex = seg.Functions[index];
       tableEntriesRel[functionIndex] = index;
       tableEntries[functionIndex] = offset + index;
     }
   }

lld/wasm/OutputSections.cpp

for (OutputSegment *segment : segments) {
     if (!segment->requiredInBinary())
       continue;
     raw_string_ostream os(segment->header);
     writeUleb128(os, segment->initFlags, "init flags");
     if (segment->initFlags & WASM_DATA_SEGMENT_HAS_MEMINDEX)
       writeUleb128(os, 0, "memory index");
     if ((segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
       WasmInitExpr initExpr;
+      initExpr.Extended = false;
       if (config->isPic) {
-        initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
-        initExpr.Value.Global = WasmSym::memoryBase->getGlobalIndex();
+        initExpr.Inst.Opcode = WASM_OPCODE_GLOBAL_GET;
+        initExpr.Inst.Value.Global = WasmSym::memoryBase->getGlobalIndex();
       } else {
         initExpr = intConst(segment->startVA, config->is64.getValueOr(false));
       }
       writeInitExpr(os, initExpr);
     }
     writeUleb128(os, segment->size, "segment size");
     os.flush();
 

lld/wasm/SyntheticSections.cpp

void ElemSection::writeBody() {
   uint32_t flags = 0;
   if (tableNumber)
     flags |= WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER;
   writeUleb128(os, flags, "elem segment flags");
   if (flags & WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
     writeUleb128(os, tableNumber, "table number");
 
   WasmInitExpr initExpr;
+  initExpr.Extended = false;
   if (config->isPic) {
-    initExpr.Opcode = WASM_OPCODE_GLOBAL_GET;
-    initExpr.Value.Global =
+    initExpr.Inst.Opcode = WASM_OPCODE_GLOBAL_GET;
+    initExpr.Inst.Value.Global =
         (config->is64.getValueOr(false) ? WasmSym::tableBase32
                                         : WasmSym::tableBase)
             ->getGlobalIndex();
   } else {
-    initExpr.Opcode = WASM_OPCODE_I32_CONST;
-    initExpr.Value.Int32 = config->tableBase;
+    initExpr.Inst.Opcode = WASM_OPCODE_I32_CONST;
+    initExpr.Inst.Value.Int32 = config->tableBase;
   }
   writeInitExpr(os, initExpr);
 
   if (flags & WASM_ELEM_SEGMENT_MASK_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;
     writeU8(os, elemKind, "elem kind");

lld/wasm/WriterUtils.h

 
 void writePtrConst(raw_ostream &os, int64_t number, bool is64,
                    const Twine &msg);
 
 void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset);
 
 void writeInitExpr(raw_ostream &os, const llvm::wasm::WasmInitExpr &initExpr);
 
+void writeInitExprMVP(raw_ostream &os,
+                      const llvm::wasm::WasmInitExprMVP &initExpr);
+
 void writeLimits(raw_ostream &os, const llvm::wasm::WasmLimits &limits);
 
 void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
 
 void writeTableType(raw_ostream &os, const llvm::wasm::WasmTableType &type);
 
 void writeImport(raw_ostream &os, const llvm::wasm::WasmImport &import);
 

lld/wasm/WriterUtils.cpp

 }
 
 void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset) {
   writeUleb128(os, alignment, "alignment");
   writeUleb128(os, offset, "offset");
 }
 
 void writeInitExpr(raw_ostream &os, const WasmInitExpr &initExpr) {
+  assert(!initExpr.Extended);
+  writeInitExprMVP(os, initExpr.Inst);
+}
+
+void writeInitExprMVP(raw_ostream &os, const WasmInitExprMVP &initExpr) {
   writeU8(os, initExpr.Opcode, "opcode");
   switch (initExpr.Opcode) {
   case WASM_OPCODE_I32_CONST:
     writeSleb128(os, initExpr.Value.Int32, "literal (i32)");
     break;
   case WASM_OPCODE_I64_CONST:
     writeSleb128(os, initExpr.Value.Int64, "literal (i64)");
     break;

llvm/include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmTable {
   uint32_t Index;
   WasmTableType Type;
   StringRef SymbolName; // from the "linking" section
 };
 
-struct WasmInitExpr {
+struct WasmInitExprMVP {
   uint8_t Opcode;
   union {
     int32_t Int32;
     int64_t Int64;
     uint32_t Float32;
     uint64_t Float64;
     uint32_t Global;
   } Value;
 };
 
+struct WasmInitExpr {
+  uint8_t Extended; // Set to non-zero if extended const is used (i.e. more than
+                    // one instruction)
+  WasmInitExprMVP Inst;
+  ArrayRef<uint8_t> Body;
+};
+
 struct WasmGlobalType {
   uint8_t Type;
   bool Mutable;
 };
 
 struct WasmGlobal {
   uint32_t Index;
   WasmGlobalType Type;
enum : unsigned {
   WASM_OPCODE_GLOBAL_SET = 0x24,
   WASM_OPCODE_I32_STORE = 0x36,
   WASM_OPCODE_I64_STORE = 0x37,
   WASM_OPCODE_I32_CONST = 0x41,
   WASM_OPCODE_I64_CONST = 0x42,
   WASM_OPCODE_F32_CONST = 0x43,
   WASM_OPCODE_F64_CONST = 0x44,
   WASM_OPCODE_I32_ADD = 0x6a,
+  WASM_OPCODE_I32_SUB = 0x6b,
+  WASM_OPCODE_I32_MUL = 0x6c,
   WASM_OPCODE_I64_ADD = 0x7c,
+  WASM_OPCODE_I64_SUB = 0x7d,
+  WASM_OPCODE_I64_MUL = 0x7e,
   WASM_OPCODE_REF_NULL = 0xd0,
 };
 
 // Opcodes used in synthetic functions.
 enum : unsigned {
   WASM_OPCODE_BLOCK = 0x02,
   WASM_OPCODE_BR = 0x0c,
   WASM_OPCODE_BR_TABLE = 0x0e,

llvm/include/llvm/ObjectYAML/WasmYAML.h

 };
 
 struct Export {
   StringRef Name;
   ExportKind Kind;
   uint32_t Index;
 };
 
+struct InitExpr {
+  bool Extended;
+  wasm::WasmInitExprMVP Inst;
+  yaml::BinaryRef Body;
+};
+
 struct ElemSegment {
   uint32_t Flags;
   uint32_t TableNumber;
   ValueType ElemKind;
-  wasm::WasmInitExpr Offset;
+  InitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 struct Global {
   uint32_t Index;
   ValueType Type;
   bool Mutable;
-  wasm::WasmInitExpr InitExpr;
+  InitExpr InitExpr;
 };
 
 struct Import {
   StringRef Module;
   StringRef Field;
   ExportKind Kind;
   union {
     uint32_t SigIndex;
-    Global GlobalImport;
     Table TableImport;
     Limits Memory;
     uint32_t TagIndex;
   };
+  // Should be in the above union but fails because
+  // of missing defauilt constructor
+  Global GlobalImport;
 };
 
 struct LocalDecl {
   ValueType Type;
   uint32_t Count;
 };
 
 struct Function {
struct Relocation {
   yaml::Hex32 Offset;
   int64_t Addend;
 };
 
 struct DataSegment {
   uint32_t SectionOffset;
   uint32_t InitFlags;
   uint32_t MemoryIndex;
-  wasm::WasmInitExpr Offset;
+  InitExpr Offset;
   yaml::BinaryRef Content;
 };
 
 struct NameEntry {
   uint32_t Index;
   StringRef Name;
 };
 

 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);
+template <> struct MappingTraits<WasmYAML::InitExpr> {
+  static void mapping(IO &IO, WasmYAML::InitExpr &Expr);
 };
 
 template <> struct MappingTraits<WasmYAML::DataSegment> {
   static void mapping(IO &IO, WasmYAML::DataSegment &Segment);
 };
 
 template <> struct MappingTraits<WasmYAML::ElemSegment> {
   static void mapping(IO &IO, WasmYAML::ElemSegment &Segment);

llvm/lib/MC/WasmObjectWriter.cpp

void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_GLOBAL);
 
   encodeULEB128(Globals.size(), W->OS);
   for (const wasm::WasmGlobal &Global : Globals) {
     encodeULEB128(Global.Type.Type, W->OS);
     W->OS << char(Global.Type.Mutable);
-    W->OS << char(Global.InitExpr.Opcode);
+    if (Global.InitExpr.Extended) {
+      llvm_unreachable("extected init expressions not supported");
+    } else {
+      W->OS << char(Global.InitExpr.Inst.Opcode);
       switch (Global.Type.Type) {
       case wasm::WASM_TYPE_I32:
         encodeSLEB128(0, W->OS);
         break;
       case wasm::WASM_TYPE_I64:
         encodeSLEB128(0, W->OS);
         break;
       case wasm::WASM_TYPE_F32:
         writeI32(0);
         break;
       case wasm::WASM_TYPE_F64:
         writeI64(0);
         break;
       case wasm::WASM_TYPE_EXTERNREF:
         writeValueType(wasm::ValType::EXTERNREF);
         break;
       default:
         llvm_unreachable("unexpected type");
       }
+    }
     W->OS << char(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
   if (Tables.empty())
for (const MCSymbol &S : Asm.symbols()) {
         LLVM_DEBUG(dbgs() << "  -> segment index: " << Ref.Segment << "\n");
 
       } else if (WS.isGlobal()) {
         // A "true" Wasm global (currently just __stack_pointer)
         if (WS.isDefined()) {
           wasm::WasmGlobal Global;
           Global.Type = WS.getGlobalType();
           Global.Index = NumGlobalImports + Globals.size();
+          Global.InitExpr.Extended = false;
           switch (Global.Type.Type) {
           case wasm::WASM_TYPE_I32:
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I32_CONST;
+            Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
             break;
           case wasm::WASM_TYPE_I64:
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_I64_CONST;
+            Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_I64_CONST;
             break;
           case wasm::WASM_TYPE_F32:
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F32_CONST;
+            Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_F32_CONST;
             break;
           case wasm::WASM_TYPE_F64:
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_F64_CONST;
+            Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_F64_CONST;
             break;
           case wasm::WASM_TYPE_EXTERNREF:
-            Global.InitExpr.Opcode = wasm::WASM_OPCODE_REF_NULL;
+            Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_REF_NULL;
             break;
           default:
             llvm_unreachable("unexpected type");
           }
           assert(WasmIndices.count(&WS) == 0);
           WasmIndices[&WS] = Global.Index;
           Globals.push_back(Global);
         } else {

llvm/lib/Object/WasmObjectFile.cpp

 }
 
 static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
   return readUint8(Ctx);
 }
 
 static Error readInitExpr(wasm::WasmInitExpr &Expr,
                           WasmObjectFile::ReadContext &Ctx) {
-  Expr.Opcode = readOpcode(Ctx);
+  auto Start = Ctx.Ptr;
 
-  switch (Expr.Opcode) {
+  Expr.Extended = false;
+  Expr.Inst.Opcode = readOpcode(Ctx);
+  switch (Expr.Inst.Opcode) {
   case wasm::WASM_OPCODE_I32_CONST:
-    Expr.Value.Int32 = readVarint32(Ctx);
+    Expr.Inst.Value.Int32 = readVarint32(Ctx);
     break;
   case wasm::WASM_OPCODE_I64_CONST:
-    Expr.Value.Int64 = readVarint64(Ctx);
+    Expr.Inst.Value.Int64 = readVarint64(Ctx);
     break;
   case wasm::WASM_OPCODE_F32_CONST:
-    Expr.Value.Float32 = readFloat32(Ctx);
+    Expr.Inst.Value.Float32 = readFloat32(Ctx);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
-    Expr.Value.Float64 = readFloat64(Ctx);
+    Expr.Inst.Value.Float64 = readFloat64(Ctx);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
-    Expr.Value.Global = readULEB128(Ctx);
+    Expr.Inst.Value.Global = readULEB128(Ctx);
     break;
   case wasm::WASM_OPCODE_REF_NULL: {
     wasm::ValType Ty = static_cast<wasm::ValType>(readULEB128(Ctx));
     if (Ty != wasm::ValType::EXTERNREF) {
       return make_error<GenericBinaryError>("invalid type for ref.null",
                                             object_error::parse_failed);
     }
     break;
   }
   default:
-    return make_error<GenericBinaryError>("invalid opcode in init_expr",
-                                          object_error::parse_failed);
+    Expr.Extended = true;
   }
 
+  if (!Expr.Extended) {
     uint8_t EndOpcode = readOpcode(Ctx);
-  if (EndOpcode != wasm::WASM_OPCODE_END) {
-    return make_error<GenericBinaryError>("invalid init_expr",
-                                          object_error::parse_failed);
+    if (EndOpcode != wasm::WASM_OPCODE_END)
+      Expr.Extended = true;
+  }
+
+  if (Expr.Extended) {
+    Ctx.Ptr = Start;
+    while (1) {
+      uint8_t Opcode = readOpcode(Ctx);
+      switch (Opcode) {
+      case wasm::WASM_OPCODE_I32_CONST:
+        readVarint32(Ctx);
+        break;
+      case wasm::WASM_OPCODE_I64_CONST:
+        readVarint64(Ctx);
+        break;
+      case wasm::WASM_OPCODE_F32_CONST:
+        readFloat32(Ctx);
+        break;
+      case wasm::WASM_OPCODE_F64_CONST:
+        readFloat64(Ctx);
+        break;
+      case wasm::WASM_OPCODE_I32_ADD:
+      case wasm::WASM_OPCODE_I32_SUB:
+      case wasm::WASM_OPCODE_I32_MUL:
+      case wasm::WASM_OPCODE_I64_ADD:
+      case wasm::WASM_OPCODE_I64_SUB:
+      case wasm::WASM_OPCODE_I64_MUL:
+        break;
+      case wasm::WASM_OPCODE_GLOBAL_GET:
+      case wasm::WASM_OPCODE_REF_NULL:
+        readULEB128(Ctx);
+        break;
+      case wasm::WASM_OPCODE_END:
+        Expr.Body = ArrayRef<uint8_t>(Start, Ctx.Ptr - Start);
+        return Error::success();
+      default:
+        return make_error<GenericBinaryError>(
+            Twine("invalid opcode in init_expr: ") + Twine(unsigned(Opcode)),
       }
+    }
+  }
+
   return Error::success();
 }
 
 static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
   wasm::WasmLimits Result;
   Result.Flags = readVaruint32(Ctx);
   Result.Minimum = readVaruint64(Ctx);
   if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
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;
+      Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
+      Segment.Offset.Inst.Value.Int32 = 0;
     } else {
       if (Error Err = readInitExpr(Segment.Offset, Ctx))
         return Err;
     }
 
     if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_KIND) {
       Segment.ElemKind = readUint8(Ctx);
       if (Segment.Flags & wasm::WASM_ELEM_SEGMENT_HAS_INIT_EXPRS) {
while (Count--) {
     Segment.Data.MemoryIndex =
         (Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
             ? readVaruint32(Ctx)
             : 0;
     if ((Segment.Data.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
       if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
         return Err;
     } else {
-      Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
-      Segment.Data.Offset.Value.Int32 = 0;
+      Segment.Data.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
+      Segment.Data.Offset.Inst.Value.Int32 = 0;
     }
     uint32_t Size = readVaruint32(Ctx);
     if (Size > (size_t)(Ctx.End - Ctx.Ptr))
       return make_error<GenericBinaryError>("invalid segment size",
                                             object_error::parse_failed);
     Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
     // The rest of these Data fields are set later, when reading in the linking
     // metadata section.
uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
   case wasm::WASM_SYMBOL_TYPE_TAG:
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_DATA: {
     // The value of a data symbol is the segment offset, plus the symbol
     // offset within the segment.
     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
-    if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST) {
-      return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
-    } else if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I64_CONST) {
-      return Segment.Offset.Value.Int64 + Sym.Info.DataRef.Offset;
+    if (Segment.Offset.Extended) {
+      llvm_unreachable("extended init exprs not supported");
+    } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
+      return Segment.Offset.Inst.Value.Int32 + Sym.Info.DataRef.Offset;
+    } else if (Segment.Offset.Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
+      return Segment.Offset.Inst.Value.Int64 + Sym.Info.DataRef.Offset;
     } else {
       llvm_unreachable("unknown init expr opcode");
     }
   }
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return 0;
   }
   llvm_unreachable("invalid symbol type");

llvm/lib/ObjectYAML/WasmEmitter.cpp

public:
   WasmWriter(WasmYAML::Object &Obj, yaml::ErrorHandler EH)
       : Obj(Obj), ErrHandler(EH) {}
   bool writeWasm(raw_ostream &OS);
 
 private:
   void writeRelocSection(raw_ostream &OS, WasmYAML::Section &Sec,
                          uint32_t SectionIndex);
 
-  void writeInitExpr(raw_ostream &OS, const wasm::WasmInitExpr &InitExpr);
+  void writeInitExpr(raw_ostream &OS, const WasmYAML::InitExpr &InitExpr);
 
   void writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::TagSection &Section);

 }
 
 void WasmWriter::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
 
 void WasmWriter::writeInitExpr(raw_ostream &OS,
-                               const wasm::WasmInitExpr &InitExpr) {
-  writeUint8(OS, InitExpr.Opcode);
-  switch (InitExpr.Opcode) {
+                               const WasmYAML::InitExpr &InitExpr) {
+  if (InitExpr.Extended) {
+    InitExpr.Body.writeAsBinary(OS);
+  } else {
+    writeUint8(OS, InitExpr.Inst.Opcode);
+    switch (InitExpr.Inst.Opcode) {
     case wasm::WASM_OPCODE_I32_CONST:
-    encodeSLEB128(InitExpr.Value.Int32, OS);
+      encodeSLEB128(InitExpr.Inst.Value.Int32, OS);
       break;
     case wasm::WASM_OPCODE_I64_CONST:
-    encodeSLEB128(InitExpr.Value.Int64, OS);
+      encodeSLEB128(InitExpr.Inst.Value.Int64, OS);
       break;
     case wasm::WASM_OPCODE_F32_CONST:
-    writeUint32(OS, InitExpr.Value.Float32);
+      writeUint32(OS, InitExpr.Inst.Value.Float32);
       break;
     case wasm::WASM_OPCODE_F64_CONST:
-    writeUint64(OS, InitExpr.Value.Float64);
+      writeUint64(OS, InitExpr.Inst.Value.Float64);
       break;
     case wasm::WASM_OPCODE_GLOBAL_GET:
-    encodeULEB128(InitExpr.Value.Global, OS);
+      encodeULEB128(InitExpr.Inst.Value.Global, OS);
       break;
     default:
-    reportError("unknown opcode in init_expr: " + Twine(InitExpr.Opcode));
+      reportError("unknown opcode in init_expr: " +
+                  Twine(InitExpr.Inst.Opcode));
       return;
     }
     writeUint8(OS, wasm::WASM_OPCODE_END);
   }
+}
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::DylinkSection &Section) {
   writeStringRef(Section.Name, OS);
 
   writeUint8(OS, wasm::WASM_DYLINK_MEM_INFO);
   SubSectionWriter SubSection(OS);
   raw_ostream &SubOS = SubSection.getStream();

llvm/lib/ObjectYAML/WasmYAML.cpp

 void MappingTraits<WasmYAML::Global>::mapping(IO &IO,
                                               WasmYAML::Global &Global) {
   IO.mapRequired("Index", Global.Index);
   IO.mapRequired("Type", Global.Type);
   IO.mapRequired("Mutable", Global.Mutable);
   IO.mapRequired("InitExpr", Global.InitExpr);
 }
 
-void MappingTraits<wasm::WasmInitExpr>::mapping(IO &IO,
-                                                wasm::WasmInitExpr &Expr) {
-  WasmYAML::Opcode Op = Expr.Opcode;
+void MappingTraits<WasmYAML::InitExpr>::mapping(IO &IO,
+                                                WasmYAML::InitExpr &Expr) {
+  IO.mapOptional("Extended", Expr.Extended, false);
+  if (Expr.Extended) {
+    IO.mapRequired("Body", Expr.Body);
+  } else {
+    WasmYAML::Opcode Op = Expr.Inst.Opcode;
     IO.mapRequired("Opcode", Op);
-  Expr.Opcode = Op;
-  switch (Expr.Opcode) {
+    Expr.Inst.Opcode = Op;
+    switch (Expr.Inst.Opcode) {
     case wasm::WASM_OPCODE_I32_CONST:
-    IO.mapRequired("Value", Expr.Value.Int32);
+      IO.mapRequired("Value", Expr.Inst.Value.Int32);
       break;
     case wasm::WASM_OPCODE_I64_CONST:
-    IO.mapRequired("Value", Expr.Value.Int64);
+      IO.mapRequired("Value", Expr.Inst.Value.Int64);
       break;
     case wasm::WASM_OPCODE_F32_CONST:
-    IO.mapRequired("Value", Expr.Value.Float32);
+      IO.mapRequired("Value", Expr.Inst.Value.Float32);
       break;
     case wasm::WASM_OPCODE_F64_CONST:
-    IO.mapRequired("Value", Expr.Value.Float64);
+      IO.mapRequired("Value", Expr.Inst.Value.Float64);
       break;
     case wasm::WASM_OPCODE_GLOBAL_GET:
-    IO.mapRequired("Index", Expr.Value.Global);
+      IO.mapRequired("Index", Expr.Inst.Value.Global);
       break;
     case wasm::WASM_OPCODE_REF_NULL: {
       WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF;
       IO.mapRequired("Type", Ty);
       break;
     }
     }
   }
+}
 
 void MappingTraits<WasmYAML::DataSegment>::mapping(
     IO &IO, WasmYAML::DataSegment &Segment) {
   IO.mapOptional("SectionOffset", Segment.SectionOffset);
   IO.mapRequired("InitFlags", Segment.InitFlags);
   if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX) {
     IO.mapRequired("MemoryIndex", Segment.MemoryIndex);
   } else {
     Segment.MemoryIndex = 0;
   }
   if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
     IO.mapRequired("Offset", Segment.Offset);
   } else {
-    Segment.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
-    Segment.Offset.Value.Int32 = 0;
+    Segment.Offset.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
+    Segment.Offset.Inst.Value.Int32 = 0;
   }
   IO.mapRequired("Content", Segment.Content);
 }
 
 void MappingTraits<WasmYAML::InitFunction>::mapping(
     IO &IO, WasmYAML::InitFunction &Init) {
   IO.mapRequired("Priority", Init.Priority);
   IO.mapRequired("Symbol", Init.Symbol);

llvm/test/ObjectYAML/wasm/extended_const_expressions.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !WASM
+FileHeader:
+  Version:         0x00000001
+Sections:
+  - Type:            GLOBAL
+    Globals:         
+      - Index:       0
+        Type:        I32
+        Mutable:     false
+        InitExpr:
+          # "extended" encoding of init expression:
+          # (global.get[0x23] 0x1 end[0x0b])
+          Extended:       true
+          Body:           23010b
+      - Index:       1
+        Type:        I64
+        Mutable:     false
+        InitExpr:
+          # (global.get[0x23] 0x1 i32.const[0x41] 0x2 i32.add[0x6a] end[0x0b])
+          Extended:       true
+          Body:           230141026a0b
+...
+# CHECK: --- !WASM
+# CHECK: FileHeader:
+# CHECK:   Version:           0x1
+# CHECK: Sections:
+# CHECK:  - Type:            GLOBAL
+# CHECK:    Globals:         
+# CHECK:      - Index:       0
+# CHECK:        Type:        I32
+# CHECK:        Mutable:     false
+# CHECK:        InitExpr:
+# CHECK:          Opcode:          GLOBAL_GET
+# CHECK:          Index:           1
+# CHECK:      - Index:           1
+# CHECK:        Type:            I64
+# CHECK:        Mutable:         false
+# CHECK:        InitExpr:
+# CHECK:          Extended:        true
+# CHECK:          Body:            230141026A0B
+# CHECK: ...

llvm/tools/llvm-readobj/WasmDumper.cpp

for (const SectionRef &Section : Obj->sections()) {
     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())
           W.printString("Name", Seg.Name);
         W.printNumber("Size", static_cast<uint64_t>(Seg.Content.size()));
-        if (Seg.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST)
-          W.printNumber("Offset", Seg.Offset.Value.Int32);
-        else if (Seg.Offset.Opcode == wasm::WASM_OPCODE_I64_CONST)
-          W.printNumber("Offset", Seg.Offset.Value.Int64);
-        else if (Seg.Offset.Opcode == wasm::WASM_OPCODE_GLOBAL_GET) {
+        if (Seg.Offset.Extended)
+          llvm_unreachable("extended const exprs not supported");
+        else if (Seg.Offset.Inst.Opcode == wasm::WASM_OPCODE_I32_CONST)
+          W.printNumber("Offset", Seg.Offset.Inst.Value.Int32);
+        else if (Seg.Offset.Inst.Opcode == wasm::WASM_OPCODE_I64_CONST)
+          W.printNumber("Offset", Seg.Offset.Inst.Value.Int64);
+        else if (Seg.Offset.Inst.Opcode == wasm::WASM_OPCODE_GLOBAL_GET) {
           ListScope Group(W, "Offset");
-          W.printNumber("Global", Seg.Offset.Value.Global);
+          W.printNumber("Global", Seg.Offset.Inst.Value.Global);
         } else
           llvm_unreachable("unknown init expr opcode");
       }
       break;
     }
     case wasm::WASM_SEC_MEMORY:
       ListScope Group(W, "Memories");
       for (const wasm::WasmLimits &Memory : Obj->memories()) {

llvm/tools/obj2yaml/wasm2yaml.cpp

for (const auto &Sec : Obj.sections()) {
     }
     case wasm::WASM_SEC_GLOBAL: {
       auto GlobalSec = std::make_unique<WasmYAML::GlobalSection>();
       for (auto &Global : Obj.globals()) {
         WasmYAML::Global G;
         G.Index = Global.Index;
         G.Type = Global.Type.Type;
         G.Mutable = Global.Type.Mutable;
-        G.InitExpr = Global.InitExpr;
+        G.InitExpr.Extended = Global.InitExpr.Extended;
+        if (Global.InitExpr.Extended) {
+          G.InitExpr.Body = Global.InitExpr.Body;
+        } else {
+          G.InitExpr.Inst = Global.InitExpr.Inst;
+        }
         GlobalSec->Globals.push_back(G);
       }
       S = std::move(GlobalSec);
       break;
     }
     case wasm::WASM_SEC_START: {
       auto StartSec = std::make_unique<WasmYAML::StartSection>();
       StartSec->StartFunction = Obj.startFunction();
for (const auto &Sec : Obj.sections()) {
     }
     case wasm::WASM_SEC_ELEM: {
       auto ElemSec = std::make_unique<WasmYAML::ElemSection>();
       for (auto &Segment : Obj.elements()) {
         WasmYAML::ElemSegment Seg;
         Seg.Flags = Segment.Flags;
         Seg.TableNumber = Segment.TableNumber;
         Seg.ElemKind = Segment.ElemKind;
-        Seg.Offset = Segment.Offset;
+        Seg.Offset.Extended = Segment.Offset.Extended;
+        if (Seg.Offset.Extended) {
+          Seg.Offset.Body = yaml::BinaryRef(Segment.Offset.Body);
+        } else {
+          Seg.Offset.Inst = Segment.Offset.Inst;
+        }
         append_range(Seg.Functions, Segment.Functions);
         ElemSec->Segments.push_back(Seg);
       }
       S = std::move(ElemSec);
       break;
     }
     case wasm::WASM_SEC_CODE: {
       auto CodeSec = std::make_unique<WasmYAML::CodeSection>();
for (const auto &Sec : Obj.sections()) {
     }
     case wasm::WASM_SEC_DATA: {
       auto DataSec = std::make_unique<WasmYAML::DataSection>();
       for (const object::WasmSegment &Segment : Obj.dataSegments()) {
         WasmYAML::DataSegment Seg;
         Seg.SectionOffset = Segment.SectionOffset;
         Seg.InitFlags = Segment.Data.InitFlags;
         Seg.MemoryIndex = Segment.Data.MemoryIndex;
-        Seg.Offset = Segment.Data.Offset;
+        Seg.Offset.Extended = Segment.Data.Offset.Extended;
+        if (Seg.Offset.Extended) {
+          Seg.Offset.Body = yaml::BinaryRef(Segment.Data.Offset.Body);
+        } else {
+          Seg.Offset.Inst = Segment.Data.Offset.Inst;
+        }
         Seg.Content = yaml::BinaryRef(Segment.Data.Content);
         DataSec->Segments.push_back(Seg);
       }
       S = std::move(DataSec);
       break;
     }
     case wasm::WASM_SEC_DATACOUNT: {
       auto DataCountSec = std::make_unique<WasmYAML::DataCountSection>();