Initial multivalue support (#2675)

Implements parsing and emitting of tuple creation and extraction and tuple-typed control flow for both the text and binary formats.

TODO:
 - Extend Precompute/interpreter to handle tuple values
 - C and JS API support/testing
 - Figure out how to lower in stack IR
 - Fuzzing

Author: tlively

auto_update_tests.py

@@ -334,10 +334,10 @@ def update_spec_tests():
     ('wasm-metadce', update_metadce_tests),
     ('wasm-reduce', update_reduce_tests),
     ('spec', update_spec_tests),
-    ('binaryenjs', update_binaryen_js_tests),
     ('lld', lld.update_lld_tests),
     ('wasm2js', wasm2js.update_wasm2js_tests),
     ('binfmt', update_bin_fmt_tests),
+    ('binaryenjs', update_binaryen_js_tests),
 ])
 
 

scripts/gen-s-parser.py

@@ -480,7 +480,10 @@
     ("try",                  "makeTry(s)"),
     ("throw",                "makeThrow(s)"),
     ("rethrow",              "makeRethrow(s)"),
-    ("br_on_exn",            "makeBrOnExn(s)")
+    ("br_on_exn",            "makeBrOnExn(s)"),
+    # Multivalue pseudoinstructions
+    ("tuple.make",           "makeTupleMake(s)"),
+    ("tuple.extract",        "makeTupleExtract(s)")
 ]
 
 

src/gen-s-parser.inc

@@ -2562,6 +2562,17 @@ switch (op[0]) {
       case 'r':
         if (strcmp(op, "try") == 0) { return makeTry(s); }
         goto parse_error;
+      case 'u': {
+        switch (op[6]) {
+          case 'e':
+            if (strcmp(op, "tuple.extract") == 0) { return makeTupleExtract(s); }
+            goto parse_error;
+          case 'm':
+            if (strcmp(op, "tuple.make") == 0) { return makeTupleMake(s); }
+            goto parse_error;
+          default: goto parse_error;
+        }
+      }
       default: goto parse_error;
     }
   }

src/ir/ExpressionAnalyzer.cpp

@@ -233,6 +233,10 @@ template<typename T> void visitImmediates(Expression* curr, T& visitor) {
     void visitUnreachable(Unreachable* curr) {}
     void visitPush(Push* curr) {}
     void visitPop(Pop* curr) {}
+    void visitTupleMake(TupleMake* curr) {}
+    void visitTupleExtract(TupleExtract* curr) {
+      visitor.visitIndex(curr->index);
+    }
   } singleton(curr, visitor);
 }
 

src/ir/ExpressionManipulator.cpp

@@ -261,6 +261,16 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
       return builder.makePush(copy(curr->value));
     }
     Expression* visitPop(Pop* curr) { return builder.makePop(curr->type); }
+    Expression* visitTupleMake(TupleMake* curr) {
+      std::vector<Expression*> operands;
+      for (auto* op : curr->operands) {
+        operands.push_back(copy(op));
+      }
+      return builder.makeTupleMake(std::move(operands));
+    }
+    Expression* visitTupleExtract(TupleExtract* curr) {
+      return builder.makeTupleExtract(copy(curr->tuple), curr->index);
+    }
   };
 
   Copier copier(wasm, custom);

src/ir/ReFinalize.cpp

@@ -137,6 +137,8 @@ void ReFinalize::visitNop(Nop* curr) { curr->finalize(); }
 void ReFinalize::visitUnreachable(Unreachable* curr) { curr->finalize(); }
 void ReFinalize::visitPush(Push* curr) { curr->finalize(); }
 void ReFinalize::visitPop(Pop* curr) { curr->finalize(); }
+void ReFinalize::visitTupleMake(TupleMake* curr) { curr->finalize(); }
+void ReFinalize::visitTupleExtract(TupleExtract* curr) { curr->finalize(); }
 
 void ReFinalize::visitFunction(Function* curr) {
   // we may have changed the body from unreachable to none, which might be bad

src/ir/effects.h

@@ -452,6 +452,8 @@ struct EffectAnalyzer
   void visitUnreachable(Unreachable* curr) { branches = true; }
   void visitPush(Push* curr) { calls = true; }
   void visitPop(Pop* curr) { calls = true; }
+  void visitTupleMake(TupleMake* curr) {}
+  void visitTupleExtract(TupleExtract* curr) {}
 
   // Helpers
 

src/ir/module-utils.h

@@ -418,7 +418,7 @@ template<typename T> struct CallGraphPropertyAnalysis {
   }
 };
 
-// Helper function for collecting the type signature used in a module
+// Helper function for collecting the type signatures used in a module
 //
 // Used when emitting or printing a module to give signatures canonical
 // indices. Signatures are sorted in order of decreasing frequency to minize the
@@ -441,6 +441,12 @@ collectSignatures(Module& wasm,
       TypeCounter(Counts& counts) : counts(counts) {}
 
       void visitCallIndirect(CallIndirect* curr) { counts[curr->sig]++; }
+      void visitBlock(Block* curr) {
+        // TODO: Allow blocks to have input types as well
+        if (curr->type.isMulti()) {
+          counts[Signature(Type::none, curr->type)]++;
+        }
+      }
     };
     TypeCounter(counts).walk(func->body);
   };

src/ir/utils.h

@@ -157,6 +157,8 @@ struct ReFinalize
   void visitUnreachable(Unreachable* curr);
   void visitPush(Push* curr);
   void visitPop(Pop* curr);
+  void visitTupleMake(TupleMake* curr);
+  void visitTupleExtract(TupleExtract* curr);
 
   void visitFunction(Function* curr);
 
@@ -224,6 +226,8 @@ struct ReFinalizeNode : public OverriddenVisitor<ReFinalizeNode> {
   void visitUnreachable(Unreachable* curr) { curr->finalize(); }
   void visitPush(Push* curr) { curr->finalize(); }
   void visitPop(Pop* curr) { curr->finalize(); }
+  void visitTupleMake(TupleMake* curr) { curr->finalize(); }
+  void visitTupleExtract(TupleExtract* curr) { curr->finalize(); }
 
   void visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }
   void visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }

src/passes/DeadCodeElimination.cpp

@@ -365,6 +365,10 @@ struct DeadCodeElimination
           DELEGATE(Rethrow);
         case Expression::Id::BrOnExnId:
           DELEGATE(BrOnExn);
+        case Expression::Id::TupleMakeId:
+          DELEGATE(TupleMake);
+        case Expression::Id::TupleExtractId:
+          DELEGATE(TupleExtract);
         case Expression::Id::InvalidId:
           WASM_UNREACHABLE("unimp");
         case Expression::Id::NumExpressionIds:

src/passes/Precompute.cpp

@@ -188,7 +188,11 @@ struct Precompute
     }
     // try to evaluate this into a const
     Flow flow = precomputeExpression(curr);
-    if (flow.value.type.isVector()) {
+    if (flow.values.size() > 1) {
+      // TODO: handle multivalue types
+      return;
+    }
+    if (flow.getSingleValue().type.isVector()) {
       return;
     }
     if (flow.breaking()) {
@@ -199,25 +203,26 @@ struct Precompute
         // this expression causes a return. if it's already a return, reuse the
         // node
         if (auto* ret = curr->dynCast<Return>()) {
-          if (flow.value.type != Type::none) {
+          if (flow.getSingleValue().type != Type::none) {
             // reuse a const value if there is one
             if (ret->value) {
               if (auto* value = ret->value->dynCast<Const>()) {
-                value->value = flow.value;
+                value->value = flow.getSingleValue();
                 value->finalize();
                 return;
               }
             }
-            ret->value = Builder(*getModule()).makeConstExpression(flow.value);
+            ret->value =
+              Builder(*getModule()).makeConstExpression(flow.getSingleValue());
           } else {
             ret->value = nullptr;
           }
         } else {
           Builder builder(*getModule());
-          replaceCurrent(
-            builder.makeReturn(flow.value.type != Type::none
-                                 ? builder.makeConstExpression(flow.value)
-                                 : nullptr));
+          replaceCurrent(builder.makeReturn(
+            flow.getSingleValue().type != Type::none
+              ? builder.makeConstExpression(flow.getSingleValue())
+              : nullptr));
         }
         return;
       }
@@ -226,34 +231,36 @@ struct Precompute
       if (auto* br = curr->dynCast<Break>()) {
         br->name = flow.breakTo;
         br->condition = nullptr;
-        if (flow.value.type != Type::none) {
+        if (flow.getSingleValue().type != Type::none) {
           // reuse a const value if there is one
           if (br->value) {
             if (auto* value = br->value->dynCast<Const>()) {
-              value->value = flow.value;
+              value->value = flow.getSingleValue();
               value->finalize();
               br->finalize();
               return;
             }
           }
-          br->value = Builder(*getModule()).makeConstExpression(flow.value);
+          br->value =
+            Builder(*getModule()).makeConstExpression(flow.getSingleValue());
         } else {
           br->value = nullptr;
         }
         br->finalize();
       } else {
         Builder builder(*getModule());
-        replaceCurrent(
-          builder.makeBreak(flow.breakTo,
-                            flow.value.type != Type::none
-                              ? builder.makeConstExpression(flow.value)
-                              : nullptr));
+        replaceCurrent(builder.makeBreak(
+          flow.breakTo,
+          flow.getSingleValue().type != Type::none
+            ? builder.makeConstExpression(flow.getSingleValue())
+            : nullptr));
       }
       return;
     }
     // this was precomputed
-    if (flow.value.type.isConcrete()) {
-      replaceCurrent(Builder(*getModule()).makeConstExpression(flow.value));
+    if (flow.getSingleValue().type.isConcrete()) {
+      replaceCurrent(
+        Builder(*getModule()).makeConstExpression(flow.getSingleValue()));
       worked = true;
     } else {
       ExpressionManipulator::nop(curr);
@@ -292,7 +299,7 @@ struct Precompute
     if (flow.breaking()) {
       return Literal();
     }
-    return flow.value;
+    return flow.getSingleValue();
   }
 
   // Propagates values around. Returns whether we propagated.

src/passes/Print.cpp

@@ -57,6 +57,28 @@ static std::ostream& printLocal(Index index, Function* func, std::ostream& o) {
   return printName(name, o);
 }
 
+// Unlike the default format, tuple types in s-expressions should not have
+// commas.
+struct LocalType {
+  Type type;
+  LocalType(Type type) : type(type){};
+};
+
+static std::ostream& operator<<(std::ostream& o, const LocalType& localType) {
+  Type type = localType.type;
+  if (type.isMulti()) {
+    const std::vector<Type>& types = type.expand();
+    o << '(' << types[0];
+    for (size_t i = 1; i < types.size(); ++i) {
+      o << ' ' << types[i];
+    }
+    o << ')';
+    return o;
+  }
+  o << type;
+  return o;
+}
+
 // Wrapper for printing signature names
 struct SigName {
   Signature sig;
@@ -1387,6 +1409,11 @@ struct PrintExpressionContents
     o << ".pop";
     restoreNormalColor(o);
   }
+  void visitTupleMake(TupleMake* curr) { printMedium(o, "tuple.make"); }
+  void visitTupleExtract(TupleExtract* curr) {
+    printMedium(o, "tuple.extract ");
+    o << curr->index;
+  }
 };
 
 // Prints an expression in s-expr format, including both the
@@ -1955,6 +1982,22 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
     PrintExpressionContents(currFunction, o).visit(curr);
     o << ')';
   }
+  void visitTupleMake(TupleMake* curr) {
+    o << '(';
+    PrintExpressionContents(currFunction, o).visit(curr);
+    incIndent();
+    for (auto operand : curr->operands) {
+      printFullLine(operand);
+    }
+    decIndent();
+  }
+  void visitTupleExtract(TupleExtract* curr) {
+    o << '(';
+    PrintExpressionContents(currFunction, o).visit(curr);
+    incIndent();
+    printFullLine(curr->tuple);
+    decIndent();
+  }
   // Module-level visitors
   void handleSignature(Signature curr, Name* funcName = nullptr) {
     o << "(func";
@@ -2093,7 +2136,8 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
       doIndent(o, indent);
       o << '(';
       printMinor(o, "local ");
-      printLocal(i, currFunction, o) << ' ' << curr->getLocalType(i) << ')';
+      printLocal(i, currFunction, o)
+        << ' ' << LocalType(curr->getLocalType(i)) << ')';
       o << maybeNewLine;
     }
     // Print the body.

src/support/small_vector.h

@@ -41,6 +41,11 @@ template<typename T, size_t N> class SmallVector {
   using value_type = T;
 
   SmallVector() {}
+  SmallVector(std::initializer_list<T> init) {
+    for (T item : init) {
+      push_back(item);
+    }
+  }
 
   T& operator[](size_t i) {
     return const_cast<T&>(static_cast<const SmallVector<T, N>&>(*this)[i]);

src/wasm-binary.h

@@ -1179,8 +1179,8 @@ class WasmBinaryBuilder {
 
   struct BreakTarget {
     Name name;
-    int arity;
-    BreakTarget(Name name, int arity) : name(name), arity(arity) {}
+    Type type;
+    BreakTarget(Name name, Type type) : name(name), type(type) {}
   };
   std::vector<BreakTarget> breakStack;
   // the names that breaks target. this lets us know if a block has breaks to it
@@ -1226,8 +1226,11 @@ class WasmBinaryBuilder {
   void processExpressions();
   void skipUnreachableCode();
 
+  void pushExpression(Expression* curr);
   Expression* popExpression();
   Expression* popNonVoidExpression();
+  Expression* popTuple(size_t numElems);
+  Expression* popTypedExpression(Type type);
 
   void validateBinary(); // validations that cannot be performed on the Module
   void processFunctions();

src/wasm-builder.h

@@ -601,6 +601,19 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  TupleMake* makeTupleMake(std::vector<Expression*>&& operands) {
+    auto* ret = allocator.alloc<TupleMake>();
+    ret->operands.set(operands);
+    ret->finalize();
+    return ret;
+  }
+  TupleExtract* makeTupleExtract(Expression* tuple, Index index) {
+    auto* ret = allocator.alloc<TupleExtract>();
+    ret->tuple = tuple;
+    ret->index = index;
+    ret->finalize();
+    return ret;
+  }
 
   // Additional helpers