7 files changed, 248 insertions, 0 deletions
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index d308d88e4..56bb94b50 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -2668,6 +2668,81 @@ void BinaryenSIMDLoadSetPtr(BinaryenExpressionRef expr,
   assert(ptrExpr);
   static_cast<SIMDLoad*>(expression)->ptr = (Expression*)ptrExpr;
 }
+// SIMDLoadStoreLane
+BinaryenOp BinaryenSIMDLoadStoreLaneGetOp(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->op;
+}
+void BinaryenSIMDLoadStoreLaneSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  static_cast<SIMDLoadStoreLane*>(expression)->op = SIMDLoadStoreLaneOp(op);
+}
+uint32_t BinaryenSIMDLoadStoreLaneGetOffset(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->offset;
+}
+void BinaryenSIMDLoadStoreLaneSetOffset(BinaryenExpressionRef expr,
+                                        uint32_t offset) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  static_cast<SIMDLoadStoreLane*>(expression)->offset = offset;
+}
+uint32_t BinaryenSIMDLoadStoreLaneGetAlign(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->align;
+}
+void BinaryenSIMDLoadStoreLaneSetAlign(BinaryenExpressionRef expr,
+                                       uint32_t align) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  static_cast<SIMDLoadStoreLane*>(expression)->align = align;
+}
+uint8_t BinaryenSIMDLoadStoreLaneGetIndex(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->index;
+}
+void BinaryenSIMDLoadStoreLaneSetIndex(BinaryenExpressionRef expr,
+                                       uint8_t index) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  static_cast<SIMDLoadStoreLane*>(expression)->index = index;
+}
+BinaryenExpressionRef
+BinaryenSIMDLoadStoreLaneGetPtr(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->ptr;
+}
+void BinaryenSIMDLoadStoreLaneSetPtr(BinaryenExpressionRef expr,
+                                     BinaryenExpressionRef ptrExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  assert(ptrExpr);
+  static_cast<SIMDLoadStoreLane*>(expression)->ptr = (Expression*)ptrExpr;
+}
+BinaryenExpressionRef
+BinaryenSIMDLoadStoreLaneGetVec(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->vec;
+}
+void BinaryenSIMDLoadStoreLaneSetVec(BinaryenExpressionRef expr,
+                                     BinaryenExpressionRef vecExpr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  assert(vecExpr);
+  static_cast<SIMDLoadStoreLane*>(expression)->vec = (Expression*)vecExpr;
+}
+bool BinaryenSIMDLoadStoreLaneIsStore(BinaryenExpressionRef expr) {
+  auto* expression = (Expression*)expr;
+  assert(expression->is<SIMDLoadStoreLane>());
+  return static_cast<SIMDLoadStoreLane*>(expression)->isStore();
+}
 // MemoryInit
 uint32_t BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 8e436de66..a4210a8db 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -1654,6 +1654,50 @@ BinaryenSIMDLoadGetPtr(BinaryenExpressionRef expr);
 BINARYEN_API void BinaryenSIMDLoadSetPtr(BinaryenExpressionRef expr,
                                          BinaryenExpressionRef ptrExpr);
 
+// SIMDLoadStoreLane
+
+// Gets the operation being performed by a SIMD load/store lane expression.
+BINARYEN_API BinaryenOp
+BinaryenSIMDLoadStoreLaneGetOp(BinaryenExpressionRef expr);
+// Sets the operation being performed by a SIMD load/store lane expression.
+BINARYEN_API void BinaryenSIMDLoadStoreLaneSetOp(BinaryenExpressionRef expr,
+                                                 BinaryenOp op);
+// Gets the constant offset of a SIMD load/store lane expression.
+BINARYEN_API uint32_t
+BinaryenSIMDLoadStoreLaneGetOffset(BinaryenExpressionRef expr);
+// Sets the constant offset of a SIMD load/store lane expression.
+BINARYEN_API void BinaryenSIMDLoadStoreLaneSetOffset(BinaryenExpressionRef expr,
+                                                     uint32_t offset);
+// Gets the byte alignment of a SIMD load/store lane expression.
+BINARYEN_API uint32_t
+BinaryenSIMDLoadStoreLaneGetAlign(BinaryenExpressionRef expr);
+// Sets the byte alignment of a SIMD load/store lane expression.
+BINARYEN_API void BinaryenSIMDLoadStoreLaneSetAlign(BinaryenExpressionRef expr,
+                                                    uint32_t align);
+// Gets the lane index of a SIMD load/store lane expression.
+BINARYEN_API uint8_t
+BinaryenSIMDLoadStoreLaneGetIndex(BinaryenExpressionRef expr);
+// Sets the lane index of a SIMD load/store lane expression.
+BINARYEN_API void BinaryenSIMDLoadStoreLaneSetIndex(BinaryenExpressionRef expr,
+                                                    uint8_t index);
+// Gets the pointer expression of a SIMD load/store lane expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenSIMDLoadStoreLaneGetPtr(BinaryenExpressionRef expr);
+// Sets the pointer expression of a SIMD load/store lane expression.
+BINARYEN_API void
+BinaryenSIMDLoadStoreLaneSetPtr(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef ptrExpr);
+// Gets the vector expression of a SIMD load/store lane expression.
+BINARYEN_API BinaryenExpressionRef
+BinaryenSIMDLoadStoreLaneGetVec(BinaryenExpressionRef expr);
+// Sets the vector expression of a SIMD load/store lane expression.
+BINARYEN_API void
+BinaryenSIMDLoadStoreLaneSetVec(BinaryenExpressionRef expr,
+                                BinaryenExpressionRef vecExpr);
+// Gets whether a SIMD load/store lane expression performs a store. Otherwise it
+// performs a load.
+BINARYEN_API bool BinaryenSIMDLoadStoreLaneIsStore(BinaryenExpressionRef expr);
+
 // MemoryInit
 
 // Gets the index of the segment being initialized by a `memory.init`
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 96dad5e7b..8e0120e36 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -82,6 +82,7 @@ function initializeConstants() {
     'SIMDTernary',
     'SIMDShift',
     'SIMDLoad',
+    'SIMDLoadStoreLane',
     'MemoryInit',
     'DataDrop',
     'MemoryCopy',
@@ -2998,6 +2999,17 @@ Module['getExpressionInfo'] = function(expr) {
         'align': Module['_BinaryenSIMDLoadGetAlign'](expr),
         'ptr': Module['_BinaryenSIMDLoadGetPtr'](expr)
       };
+    case Module['SIMDLoadStoreLaneId']:
+      return {
+        'id': id,
+        'type': type,
+        'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expr),
+        'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expr),
+        'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expr),
+        'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expr),
+        'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expr),
+        'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expr)
+      };
     case Module['MemoryInitId']:
       return {
         'id': id,
@@ -4243,6 +4255,48 @@ Module['SIMDLoad'] = makeExpressionWrapper({
   }
 });
 
+Module['SIMDLoadStoreLane'] = makeExpressionWrapper({
+  'getOp'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetOp'](expr);
+  },
+  'setOp'(expr, op) {
+    Module['_BinaryenSIMDLoadStoreLaneSetOp'](expr, op);
+  },
+  'getOffset'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expr);
+  },
+  'setOffset'(expr, offset) {
+    Module['_BinaryenSIMDLoadStoreLaneSetOffset'](expr, offset);
+  },
+  'getAlign'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expr);
+  },
+  'setAlign'(expr, align) {
+    Module['_BinaryenSIMDLoadStoreLaneSetAlign'](expr, align);
+  },
+  'getIndex'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expr);
+  },
+  'setIndex'(expr, align) {
+    Module['_BinaryenSIMDLoadStoreLaneSetIndex'](expr, align);
+  },
+  'getPtr'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expr);
+  },
+  'setPtr'(expr, ptrExpr) {
+    Module['_BinaryenSIMDLoadStoreLaneSetPtr'](expr, ptrExpr);
+  },
+  'getVec'(expr) {
+    return Module['_BinaryenSIMDLoadStoreLaneGetVec'](expr);
+  },
+  'setVec'(expr, ptrExpr) {
+    Module['_BinaryenSIMDLoadStoreLaneSetVec'](expr, ptrExpr);
+  },
+  'isStore'(expr) {
+    return Boolean(Module['_BinaryenSIMDLoadStoreLaneIsStore'](expr));
+  }
+});
+
 Module['MemoryInit'] = makeExpressionWrapper({
   'getSegment'(expr) {
     return Module['_BinaryenMemoryInitGetSegment'](expr);
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
index 6938bdd4c..ca45933a7 100644
--- a/test/binaryen.js/expressions.js
+++ b/test/binaryen.js/expressions.js
@@ -1207,6 +1207,68 @@ console.log("# SIMDLoad");
   module.dispose();
 })();
 
+console.log("# SIMDLoadStoreLane");
+(function testSIMDLoadStoreLane() {
+  const module = new binaryen.Module();
+
+  var op = binaryen.Operations.Load8LaneVec128;
+  var offset = 16;
+  var index = 1;
+  var align = 1;
+  var ptr = module.i32.const(1);
+  var vec = module.v128.const([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
+  const theSIMDLoadStoreLane = binaryen.SIMDLoadStoreLane(module.v128.load8_lane(offset, align, index, ptr, vec));
+  assert(theSIMDLoadStoreLane instanceof binaryen.SIMDLoadStoreLane);
+  assert(theSIMDLoadStoreLane instanceof binaryen.Expression);
+  assert(theSIMDLoadStoreLane.op === op);
+  assert(theSIMDLoadStoreLane.offset === offset);
+  assert(theSIMDLoadStoreLane.align === align);
+  assert(theSIMDLoadStoreLane.index === index);
+  assert(theSIMDLoadStoreLane.ptr === ptr);
+  assert(theSIMDLoadStoreLane.vec === vec);
+  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+  assert(theSIMDLoadStoreLane.store === false);
+
+  theSIMDLoadStoreLane.op = op = binaryen.Operations.Load16LaneVec128;
+  assert(theSIMDLoadStoreLane.op === op);
+  theSIMDLoadStoreLane.offset = offset = 32;
+  assert(theSIMDLoadStoreLane.offset === offset);
+  theSIMDLoadStoreLane.align = align = 2;
+  assert(theSIMDLoadStoreLane.align === align);
+  theSIMDLoadStoreLane.index = index = 2;
+  assert(theSIMDLoadStoreLane.index === index);
+  theSIMDLoadStoreLane.ptr = ptr = module.i32.const(2);
+  assert(theSIMDLoadStoreLane.ptr === ptr);
+  theSIMDLoadStoreLane.vec = vec = module.v128.const([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
+  assert(theSIMDLoadStoreLane.vec === vec);
+  theSIMDLoadStoreLane.type = binaryen.f64;
+  theSIMDLoadStoreLane.finalize();
+  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+
+  console.log(theSIMDLoadStoreLane.toText());
+  assert(
+    theSIMDLoadStoreLane.toText()
+    ==
+    "(v128.load16_lane offset=32 2\n (i32.const 2)\n (v128.const i32x4 0x01010101 0x01010101 0x01010101 0x01010101)\n)\n"
+  );
+
+  theSIMDLoadStoreLane.op = op = binaryen.Operations.Store16LaneVec128;
+  assert(theSIMDLoadStoreLane.op === op);
+  theSIMDLoadStoreLane.type = binaryen.f64;
+  assert(theSIMDLoadStoreLane.store === true);
+  theSIMDLoadStoreLane.finalize();
+  assert(theSIMDLoadStoreLane.type === binaryen.none);
+
+  console.log(theSIMDLoadStoreLane.toText());
+  assert(
+    theSIMDLoadStoreLane.toText()
+    ==
+    "(v128.store16_lane offset=32 2\n (i32.const 2)\n (v128.const i32x4 0x01010101 0x01010101 0x01010101 0x01010101)\n)\n"
+  );
+
+  module.dispose();
+})();
+
 console.log("# MemoryInit");
 (function testMemoryInit() {
   const module = new binaryen.Module();
diff --git a/test/binaryen.js/expressions.js.txt b/test/binaryen.js/expressions.js.txt
index a3e877b0f..1d38104af 100644
--- a/test/binaryen.js/expressions.js.txt
+++ b/test/binaryen.js/expressions.js.txt
@@ -179,6 +179,17 @@
  (i32.const 2)
 )
 
+# SIMDLoadStoreLane
+(v128.load16_lane offset=32 2
+ (i32.const 2)
+ (v128.const i32x4 0x01010101 0x01010101 0x01010101 0x01010101)
+)
+
+(v128.store16_lane offset=32 2
+ (i32.const 2)
+ (v128.const i32x4 0x01010101 0x01010101 0x01010101 0x01010101)
+)
+
 # MemoryInit
 (memory.init 5
  (i32.const 6)
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index 0798741cf..a8e69e381 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -153,6 +153,7 @@ function test_ids() {
   console.log("SIMDTernaryId: " + binaryen.SIMDTernaryId);
   console.log("SIMDShiftId: " + binaryen.SIMDShiftId);
   console.log("SIMDLoadId: " + binaryen.SIMDLoadId);
+  console.log("SIMDLoadStoreLaneId: " + binaryen.SIMDLoadStoreLaneId);
   console.log("MemoryInitId: " + binaryen.MemoryInitId);
   console.log("DataDropId: " + binaryen.DataDropId);
   console.log("MemoryCopyId: " + binaryen.MemoryCopyId);
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
index 2e9c3bc51..600795c05 100644
--- a/test/binaryen.js/kitchen-sink.js.txt
+++ b/test/binaryen.js/kitchen-sink.js.txt
@@ -77,6 +77,7 @@ SIMDShuffleId: 31
 SIMDTernaryId: 32
 SIMDShiftId: 33
 SIMDLoadId: 34
+SIMDLoadStoreLaneId: 35
 MemoryInitId: 36
 DataDropId: 37
 MemoryCopyId: 38