SIMD load and extend instructions (#2353)

Adds support for the new load and extend instructions. Also updates
from C++11 to C++17 in order to use generic lambdas in the interpreter
implementation.

3 files changed, 248 insertions, 121 deletions

diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index a321290f2..689adcae0 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -491,6 +491,30 @@ void test_core() {
       module, BinaryenLoadSplatVec32x4(), 16, 4, makeInt32(module, 128)),
     BinaryenSIMDLoad(
       module, BinaryenLoadSplatVec64x2(), 0, 4, makeInt32(module, 128)),
+    BinaryenSIMDLoad(
+      module, BinaryenLoadExtSVec8x8ToVecI16x8(), 0, 8, makeInt32(module, 128)),
+    BinaryenSIMDLoad(
+      module, BinaryenLoadExtUVec8x8ToVecI16x8(), 0, 8, makeInt32(module, 128)),
+    BinaryenSIMDLoad(module,
+                     BinaryenLoadExtSVec16x4ToVecI32x4(),
+                     0,
+                     8,
+                     makeInt32(module, 128)),
+    BinaryenSIMDLoad(module,
+                     BinaryenLoadExtUVec16x4ToVecI32x4(),
+                     0,
+                     8,
+                     makeInt32(module, 128)),
+    BinaryenSIMDLoad(module,
+                     BinaryenLoadExtSVec32x2ToVecI64x2(),
+                     0,
+                     8,
+                     makeInt32(module, 128)),
+    BinaryenSIMDLoad(module,
+                     BinaryenLoadExtUVec32x2ToVecI64x2(),
+                     0,
+                     8,
+                     makeInt32(module, 128)),
     // Other SIMD
     makeSIMDShuffle(module),
     makeSIMDTernary(module, BinaryenBitselectVec128()),
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index 417c33077..4848ec3bf 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -1319,6 +1319,36 @@ BinaryenFeatureAll: 511
        )
       )
       (drop
+       (i16x8.load8x8_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i16x8.load8x8_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_u
+        (i32.const 128)
+       )
+      )
+      (drop
        (v8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
@@ -3433,177 +3463,189 @@ int main() {
   expressions[628] = BinaryenSIMDLoad(the_module, 2, 16, 4, expressions[627]);
   expressions[629] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
   expressions[630] = BinaryenSIMDLoad(the_module, 3, 0, 4, expressions[629]);
+  expressions[631] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[632] = BinaryenSIMDLoad(the_module, 4, 0, 8, expressions[631]);
+  expressions[633] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[634] = BinaryenSIMDLoad(the_module, 5, 0, 8, expressions[633]);
+  expressions[635] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[636] = BinaryenSIMDLoad(the_module, 6, 0, 8, expressions[635]);
+  expressions[637] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[638] = BinaryenSIMDLoad(the_module, 7, 0, 8, expressions[637]);
+  expressions[639] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[640] = BinaryenSIMDLoad(the_module, 8, 0, 8, expressions[639]);
+  expressions[641] = BinaryenConst(the_module, BinaryenLiteralInt32(128));
+  expressions[642] = BinaryenSIMDLoad(the_module, 9, 0, 8, expressions[641]);
   {
     uint8_t t224[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[631] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
+    expressions[643] = BinaryenConst(the_module, BinaryenLiteralVec128(t224));
   }
   {
     uint8_t t225[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[632] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
+    expressions[644] = BinaryenConst(the_module, BinaryenLiteralVec128(t225));
   }
   {
     uint8_t mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    expressions[633] = BinaryenSIMDShuffle(the_module, expressions[631], expressions[632], mask);
+    expressions[645] = BinaryenSIMDShuffle(the_module, expressions[643], expressions[644], mask);
   }
   {
     uint8_t t226[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[634] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
+    expressions[646] = BinaryenConst(the_module, BinaryenLiteralVec128(t226));
   }
   {
     uint8_t t227[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[635] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
+    expressions[647] = BinaryenConst(the_module, BinaryenLiteralVec128(t227));
   }
   {
     uint8_t t228[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[636] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
+    expressions[648] = BinaryenConst(the_module, BinaryenLiteralVec128(t228));
   }
-  expressions[637] = BinaryenSIMDTernary(the_module, 0, expressions[634], expressions[635], expressions[636]);
+  expressions[649] = BinaryenSIMDTernary(the_module, 0, expressions[646], expressions[647], expressions[648]);
   {
     uint8_t t229[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[638] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
+    expressions[650] = BinaryenConst(the_module, BinaryenLiteralVec128(t229));
   }
   {
     uint8_t t230[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[639] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
+    expressions[651] = BinaryenConst(the_module, BinaryenLiteralVec128(t230));
   }
   {
     uint8_t t231[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[640] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
+    expressions[652] = BinaryenConst(the_module, BinaryenLiteralVec128(t231));
   }
-  expressions[641] = BinaryenSIMDTernary(the_module, 1, expressions[638], expressions[639], expressions[640]);
+  expressions[653] = BinaryenSIMDTernary(the_module, 1, expressions[650], expressions[651], expressions[652]);
   {
     uint8_t t232[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[642] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
+    expressions[654] = BinaryenConst(the_module, BinaryenLiteralVec128(t232));
   }
   {
     uint8_t t233[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[643] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
+    expressions[655] = BinaryenConst(the_module, BinaryenLiteralVec128(t233));
   }
   {
     uint8_t t234[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[644] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
+    expressions[656] = BinaryenConst(the_module, BinaryenLiteralVec128(t234));
   }
-  expressions[645] = BinaryenSIMDTernary(the_module, 2, expressions[642], expressions[643], expressions[644]);
+  expressions[657] = BinaryenSIMDTernary(the_module, 2, expressions[654], expressions[655], expressions[656]);
   {
     uint8_t t235[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[646] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
+    expressions[658] = BinaryenConst(the_module, BinaryenLiteralVec128(t235));
   }
   {
     uint8_t t236[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[647] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
+    expressions[659] = BinaryenConst(the_module, BinaryenLiteralVec128(t236));
   }
   {
     uint8_t t237[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[648] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
+    expressions[660] = BinaryenConst(the_module, BinaryenLiteralVec128(t237));
   }
-  expressions[649] = BinaryenSIMDTernary(the_module, 3, expressions[646], expressions[647], expressions[648]);
+  expressions[661] = BinaryenSIMDTernary(the_module, 3, expressions[658], expressions[659], expressions[660]);
   {
     uint8_t t238[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[650] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
+    expressions[662] = BinaryenConst(the_module, BinaryenLiteralVec128(t238));
   }
   {
     uint8_t t239[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[651] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
+    expressions[663] = BinaryenConst(the_module, BinaryenLiteralVec128(t239));
   }
   {
     uint8_t t240[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
-    expressions[652] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
-  }
-  expressions[653] = BinaryenSIMDTernary(the_module, 4, expressions[650], expressions[651], expressions[652]);
-  expressions[654] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[655] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[656] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[657] = BinaryenMemoryInit(the_module, 0, expressions[654], expressions[655], expressions[656]);
-  expressions[658] = BinaryenDataDrop(the_module, 0);
-  expressions[659] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
-  expressions[660] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[661] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
-  expressions[662] = BinaryenMemoryCopy(the_module, expressions[659], expressions[660], expressions[661]);
-  expressions[663] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[664] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
-  expressions[665] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
-  expressions[666] = BinaryenMemoryFill(the_module, expressions[663], expressions[664], expressions[665]);
+    expressions[664] = BinaryenConst(the_module, BinaryenLiteralVec128(t240));
+  }
+  expressions[665] = BinaryenSIMDTernary(the_module, 4, expressions[662], expressions[663], expressions[664]);
+  expressions[666] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[667] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[668] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[669] = BinaryenMemoryInit(the_module, 0, expressions[666], expressions[667], expressions[668]);
+  expressions[670] = BinaryenDataDrop(the_module, 0);
+  expressions[671] = BinaryenConst(the_module, BinaryenLiteralInt32(2048));
+  expressions[672] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[673] = BinaryenConst(the_module, BinaryenLiteralInt32(12));
+  expressions[674] = BinaryenMemoryCopy(the_module, expressions[671], expressions[672], expressions[673]);
+  expressions[675] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[676] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[677] = BinaryenConst(the_module, BinaryenLiteralInt32(1024));
+  expressions[678] = BinaryenMemoryFill(the_module, expressions[675], expressions[676], expressions[677]);
   {
     BinaryenExpressionRef children[] = { 0 };
-    expressions[667] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
-  }
-  expressions[668] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]);
-  expressions[669] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]);
-  expressions[670] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[671] = BinaryenLoop(the_module, "in", expressions[670]);
-  expressions[672] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
-  expressions[673] = BinaryenLoop(the_module, NULL, expressions[672]);
-  expressions[674] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]);
-  expressions[675] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[676] = BinaryenBreak(the_module, "the-nothing", expressions[675], expressions[0]);
-  expressions[677] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
-  expressions[678] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[677]);
-  expressions[679] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
+    expressions[679] = BinaryenBlock(the_module, NULL, children, 0, BinaryenTypeAuto());
+  }
+  expressions[680] = BinaryenIf(the_module, expressions[18], expressions[19], expressions[20]);
+  expressions[681] = BinaryenIf(the_module, expressions[21], expressions[22], expressions[0]);
+  expressions[682] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[683] = BinaryenLoop(the_module, "in", expressions[682]);
+  expressions[684] = BinaryenConst(the_module, BinaryenLiteralInt32(0));
+  expressions[685] = BinaryenLoop(the_module, NULL, expressions[684]);
+  expressions[686] = BinaryenBreak(the_module, "the-value", expressions[23], expressions[24]);
+  expressions[687] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[688] = BinaryenBreak(the_module, "the-nothing", expressions[687], expressions[0]);
+  expressions[689] = BinaryenConst(the_module, BinaryenLiteralInt32(3));
+  expressions[690] = BinaryenBreak(the_module, "the-value", expressions[0], expressions[689]);
+  expressions[691] = BinaryenBreak(the_module, "the-nothing", expressions[0], expressions[0]);
   {
     const char* names[] = { "the-value" };
-    expressions[680] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]);
+    expressions[692] = BinaryenSwitch(the_module, names, 1, "the-value", expressions[25], expressions[26]);
   }
-  expressions[681] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[693] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
   {
     const char* names[] = { "the-nothing" };
-    expressions[682] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[681], expressions[0]);
+    expressions[694] = BinaryenSwitch(the_module, names, 1, "the-nothing", expressions[693], expressions[0]);
   }
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[683] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
+    expressions[695] = BinaryenCall(the_module, "kitchen()sinker", operands, 4, 1);
   }
-  expressions[684] = BinaryenUnary(the_module, 20, expressions[683]);
+  expressions[696] = BinaryenUnary(the_module, 20, expressions[695]);
   {
     BinaryenExpressionRef operands[] = { expressions[8], expressions[9] };
-    expressions[685] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
+    expressions[697] = BinaryenCall(the_module, "an-imported", operands, 2, 3);
   }
-  expressions[686] = BinaryenUnary(the_module, 25, expressions[685]);
-  expressions[687] = BinaryenUnary(the_module, 20, expressions[686]);
-  expressions[688] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[698] = BinaryenUnary(the_module, 25, expressions[697]);
+  expressions[699] = BinaryenUnary(the_module, 20, expressions[698]);
+  expressions[700] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[689] = BinaryenCallIndirect(the_module, expressions[688], operands, 4, "iiIfF");
-  }
-  expressions[690] = BinaryenUnary(the_module, 20, expressions[689]);
-  expressions[691] = BinaryenLocalGet(the_module, 0, 1);
-  expressions[692] = BinaryenDrop(the_module, expressions[691]);
-  expressions[693] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
-  expressions[694] = BinaryenLocalSet(the_module, 0, expressions[693]);
-  expressions[695] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
-  expressions[696] = BinaryenLocalTee(the_module, 0, expressions[695]);
-  expressions[697] = BinaryenDrop(the_module, expressions[696]);
-  expressions[698] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
-  expressions[699] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[698]);
-  expressions[700] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
-  expressions[701] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[700]);
-  expressions[702] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
-  expressions[703] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[702]);
-  expressions[704] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
-  expressions[705] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[704]);
-  expressions[706] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1);
-  expressions[707] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2);
-  expressions[708] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]);
-  expressions[709] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
-  expressions[710] = BinaryenReturn(the_module, expressions[709]);
+    expressions[701] = BinaryenCallIndirect(the_module, expressions[700], operands, 4, "iiIfF");
+  }
+  expressions[702] = BinaryenUnary(the_module, 20, expressions[701]);
+  expressions[703] = BinaryenLocalGet(the_module, 0, 1);
+  expressions[704] = BinaryenDrop(the_module, expressions[703]);
+  expressions[705] = BinaryenConst(the_module, BinaryenLiteralInt32(101));
+  expressions[706] = BinaryenLocalSet(the_module, 0, expressions[705]);
+  expressions[707] = BinaryenConst(the_module, BinaryenLiteralInt32(102));
+  expressions[708] = BinaryenLocalTee(the_module, 0, expressions[707]);
+  expressions[709] = BinaryenDrop(the_module, expressions[708]);
+  expressions[710] = BinaryenConst(the_module, BinaryenLiteralInt32(1));
+  expressions[711] = BinaryenLoad(the_module, 4, 0, 0, 0, 1, expressions[710]);
+  expressions[712] = BinaryenConst(the_module, BinaryenLiteralInt32(8));
+  expressions[713] = BinaryenLoad(the_module, 2, 1, 2, 1, 2, expressions[712]);
+  expressions[714] = BinaryenConst(the_module, BinaryenLiteralInt32(2));
+  expressions[715] = BinaryenLoad(the_module, 4, 0, 0, 0, 3, expressions[714]);
+  expressions[716] = BinaryenConst(the_module, BinaryenLiteralInt32(9));
+  expressions[717] = BinaryenLoad(the_module, 8, 0, 2, 8, 4, expressions[716]);
+  expressions[718] = BinaryenStore(the_module, 4, 0, 0, expressions[30], expressions[31], 1);
+  expressions[719] = BinaryenStore(the_module, 8, 2, 4, expressions[32], expressions[33], 2);
+  expressions[720] = BinaryenSelect(the_module, expressions[27], expressions[28], expressions[29]);
+  expressions[721] = BinaryenConst(the_module, BinaryenLiteralInt32(1337));
+  expressions[722] = BinaryenReturn(the_module, expressions[721]);
   {
     BinaryenExpressionRef operands[] = { expressions[10], expressions[11], expressions[12], expressions[13] };
-    expressions[711] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
+    expressions[723] = BinaryenReturnCall(the_module, "kitchen()sinker", operands, 4, 1);
   }
-  expressions[712] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
+  expressions[724] = BinaryenConst(the_module, BinaryenLiteralInt32(2449));
   {
     BinaryenExpressionRef operands[] = { expressions[14], expressions[15], expressions[16], expressions[17] };
-    expressions[713] = BinaryenReturnCallIndirect(the_module, expressions[712], operands, 4, "iiIfF");
-  }
-  expressions[714] = BinaryenTry(the_module, expressions[35], expressions[43]);
-  expressions[715] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[23]);
-  expressions[716] = BinaryenAtomicStore(the_module, 4, 0, expressions[23], expressions[715], 1);
-  expressions[717] = BinaryenAtomicWait(the_module, expressions[23], expressions[23], expressions[33], 1);
-  expressions[718] = BinaryenDrop(the_module, expressions[717]);
-  expressions[719] = BinaryenAtomicNotify(the_module, expressions[23], expressions[23]);
-  expressions[720] = BinaryenDrop(the_module, expressions[719]);
-  expressions[721] = BinaryenAtomicFence(the_module);
-  expressions[722] = BinaryenNop(the_module);
-  expressions[723] = BinaryenUnreachable(the_module);
+    expressions[725] = BinaryenReturnCallIndirect(the_module, expressions[724], operands, 4, "iiIfF");
+  }
+  expressions[726] = BinaryenTry(the_module, expressions[35], expressions[43]);
+  expressions[727] = BinaryenAtomicLoad(the_module, 4, 0, 1, expressions[23]);
+  expressions[728] = BinaryenAtomicStore(the_module, 4, 0, expressions[23], expressions[727], 1);
+  expressions[729] = BinaryenAtomicWait(the_module, expressions[23], expressions[23], expressions[33], 1);
+  expressions[730] = BinaryenDrop(the_module, expressions[729]);
+  expressions[731] = BinaryenAtomicNotify(the_module, expressions[23], expressions[23]);
+  expressions[732] = BinaryenDrop(the_module, expressions[731]);
+  expressions[733] = BinaryenAtomicFence(the_module);
+  expressions[734] = BinaryenNop(the_module);
+  expressions[735] = BinaryenUnreachable(the_module);
   BinaryenExpressionPrint(expressions[51]);
 (f32.neg
  (f32.const -33.61199951171875)
@@ -3647,34 +3689,35 @@ int main() {
        expressions[580], expressions[583], expressions[586], expressions[589], expressions[592], expressions[595], 
        expressions[598], expressions[601], expressions[604], expressions[607], expressions[610], expressions[613], 
        expressions[616], expressions[619], expressions[622], expressions[624], expressions[626], expressions[628], 
-       expressions[630], expressions[633], expressions[637], expressions[641], expressions[645], expressions[649], 
-       expressions[653], expressions[657], expressions[658], expressions[662], expressions[666], expressions[667], 
-       expressions[668], expressions[669], expressions[671], expressions[673], expressions[674], expressions[676], 
-       expressions[678], expressions[679], expressions[680], expressions[682], expressions[684], expressions[687], 
-       expressions[690], expressions[692], expressions[694], expressions[697], expressions[699], expressions[701], 
-       expressions[703], expressions[705], expressions[706], expressions[707], expressions[708], expressions[710], 
-       expressions[711], expressions[713], expressions[714], expressions[716], expressions[718], expressions[720], 
-       expressions[721], expressions[722], expressions[723] };
-    expressions[724] = BinaryenBlock(the_module, "the-value", children, 272, BinaryenTypeAuto());
+       expressions[630], expressions[632], expressions[634], expressions[636], expressions[638], expressions[640], 
+       expressions[642], expressions[645], expressions[649], expressions[653], expressions[657], expressions[661], 
+       expressions[665], expressions[669], expressions[670], expressions[674], expressions[678], expressions[679], 
+       expressions[680], expressions[681], expressions[683], expressions[685], expressions[686], expressions[688], 
+       expressions[690], expressions[691], expressions[692], expressions[694], expressions[696], expressions[699], 
+       expressions[702], expressions[704], expressions[706], expressions[709], expressions[711], expressions[713], 
+       expressions[715], expressions[717], expressions[718], expressions[719], expressions[720], expressions[722], 
+       expressions[723], expressions[725], expressions[726], expressions[728], expressions[730], expressions[732], 
+       expressions[733], expressions[734], expressions[735] };
+    expressions[736] = BinaryenBlock(the_module, "the-value", children, 278, BinaryenTypeAuto());
   }
-  expressions[725] = BinaryenDrop(the_module, expressions[724]);
+  expressions[737] = BinaryenDrop(the_module, expressions[736]);
   {
-    BinaryenExpressionRef children[] = { expressions[725] };
-    expressions[726] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
+    BinaryenExpressionRef children[] = { expressions[737] };
+    expressions[738] = BinaryenBlock(the_module, "the-nothing", children, 1, BinaryenTypeAuto());
   }
-  expressions[727] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
+  expressions[739] = BinaryenConst(the_module, BinaryenLiteralInt32(42));
   {
-    BinaryenExpressionRef children[] = { expressions[726], expressions[727] };
-    expressions[728] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
+    BinaryenExpressionRef children[] = { expressions[738], expressions[739] };
+    expressions[740] = BinaryenBlock(the_module, "the-body", children, 2, BinaryenTypeAuto());
   }
   {
     BinaryenType varTypes[] = { 1, 7 };
-    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 2, expressions[728]);
+    functions[0] = BinaryenAddFunction(the_module, "kitchen()sinker", functionTypes[0], varTypes, 2, expressions[740]);
   }
-  expressions[729] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
-  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[729]);
-  expressions[730] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
-  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[730]);
+  expressions[741] = BinaryenConst(the_module, BinaryenLiteralInt32(7));
+  globals[0] = BinaryenAddGlobal(the_module, "a-global", 1, 0, expressions[741]);
+  expressions[742] = BinaryenConst(the_module, BinaryenLiteralFloat32(7.5));
+  globals[1] = BinaryenAddGlobal(the_module, "a-mutable-global", 3, 1, expressions[742]);
   {
     BinaryenType paramTypes[] = { 1, 4 };
     functionTypes[2] = BinaryenAddFunctionType(the_module, "fiF", 3, paramTypes, 2);
@@ -3686,13 +3729,13 @@ int main() {
     const char* funcNames[] = { "kitchen()sinker" };
     BinaryenSetFunctionTable(the_module, 1, 1, funcNames, 1);
   }
-  expressions[731] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
+  expressions[743] = BinaryenConst(the_module, BinaryenLiteralInt32(10));
   {
     const char segment0[] = { 104, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100 };
     const char segment1[] = { 73, 32, 97, 109, 32, 112, 97, 115, 115, 105, 118, 101 };
     const char* segments[] = { segment0, segment1 };
     int8_t segmentPassive[] = { 0, 1 };
-    BinaryenExpressionRef segmentOffsets[] = { expressions[731], expressions[0] };
+    BinaryenExpressionRef segmentOffsets[] = { expressions[743], expressions[0] };
     BinaryenIndex segmentSizes[] = { 12, 12 };
     BinaryenSetMemory(the_module, 1, 256, "mem", segments, segmentPassive, segmentOffsets, segmentSizes, 2, 1);
   }
@@ -3700,10 +3743,10 @@ int main() {
     BinaryenType paramTypes[] = { 0 };
     functionTypes[3] = BinaryenAddFunctionType(the_module, "v", 0, paramTypes, 0);
   }
-  expressions[732] = BinaryenNop(the_module);
+  expressions[744] = BinaryenNop(the_module);
   {
     BinaryenType varTypes[] = { 0 };
-    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[732]);
+    functions[1] = BinaryenAddFunction(the_module, "starter", functionTypes[3], varTypes, 0, expressions[744]);
   }
   BinaryenSetStart(the_module, functions[1]);
   {
@@ -5012,6 +5055,36 @@ int main() {
        )
       )
       (drop
+       (i16x8.load8x8_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i16x8.load8x8_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_u
+        (i32.const 128)
+       )
+      )
+      (drop
        (v8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
diff --git a/test/example/c-api-kitchen-sink.txt.txt b/test/example/c-api-kitchen-sink.txt.txt
index f8a1a1c4a..56602ef13 100644
--- a/test/example/c-api-kitchen-sink.txt.txt
+++ b/test/example/c-api-kitchen-sink.txt.txt
@@ -1298,6 +1298,36 @@
        )
       )
       (drop
+       (i16x8.load8x8_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i16x8.load8x8_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i32x4.load16x4_u
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_s
+        (i32.const 128)
+       )
+      )
+      (drop
+       (i64x2.load32x2_u
+        (i32.const 128)
+       )
+      )
+      (drop
        (v8x16.shuffle 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)
         (v128.const i32x4 0x04030201 0x08070605 0x0c0b0a09 0x100f0e0d)