Add new compound Signature, Struct and Array types

src/asmjs/asm_v_wasm.cpp

@@ -101,7 +101,7 @@ std::string getSig(Function* func) {
 }
 
 std::string getSig(Type results, Type params) {
-  assert(!results.isMulti());
+  assert(!results.isTuple());
   std::string sig;
   sig += getSig(results);
   for (Type t : params.expand()) {

src/ir/module-utils.h

@@ -409,7 +409,7 @@ collectSignatures(Module& wasm,
           counts[call->sig]++;
         } else if (Properties::isControlFlowStructure(curr)) {
           // TODO: Allow control flow to have input types as well
-          if (curr->type.isMulti()) {
+          if (curr->type.isTuple()) {
             counts[Signature(Type::none, curr->type)]++;
           }
         }

src/passes/Print.cpp

@@ -66,7 +66,7 @@ struct SExprType {
 
 static std::ostream& operator<<(std::ostream& o, const SExprType& localType) {
   Type type = localType.type;
-  if (type.isMulti()) {
+  if (type.isTuple()) {
     const std::vector<Type>& types = type.expand();
     o << '(' << types[0];
     for (size_t i = 1; i < types.size(); ++i) {

src/passes/RemoveUnusedBrs.cpp

@@ -319,7 +319,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
             // be further optimizable, and if select does not branch we also
             // avoid one branch.
             // Multivalue selects are not supported
-            if (br->value && br->value->type.isMulti()) {
+            if (br->value && br->value->type.isTuple()) {
               return;
             }
             // If running the br's condition unconditionally is too expensive,

src/tools/fuzzing.h

@@ -306,7 +306,7 @@ class TranslateToFuzzReader {
   double getDouble() { return Literal(get64()).reinterpretf64(); }
 
   Type getSubType(Type type) {
-    if (type.isMulti()) {
+    if (type.isTuple()) {
       std::vector<Type> types;
       for (auto t : type.expand()) {
         types.push_back(getSubType(t));
@@ -850,7 +850,7 @@ class TranslateToFuzzReader {
 
   Expression* _makeConcrete(Type type) {
     bool canMakeControlFlow =
-      !type.isMulti() || wasm.features.has(FeatureSet::Multivalue);
+      !type.isTuple() || wasm.features.has(FeatureSet::Multivalue);
     using Self = TranslateToFuzzReader;
     FeatureOptions<Expression* (Self::*)(Type)> options;
     using WeightedOption = decltype(options)::WeightedOption;
@@ -886,7 +886,7 @@ class TranslateToFuzzReader {
     if (type == Type::i32) {
       options.add(FeatureSet::ReferenceTypes, &Self::makeRefIsNull);
     }
-    if (type.isMulti()) {
+    if (type.isTuple()) {
       options.add(FeatureSet::Multivalue, &Self::makeTupleMake);
     }
     return (this->*pick(options))(type);
@@ -1265,7 +1265,7 @@ class TranslateToFuzzReader {
 
   Expression* makeTupleMake(Type type) {
     assert(wasm.features.hasMultivalue());
-    assert(type.isMulti());
+    assert(type.isTuple());
     std::vector<Expression*> elements;
     for (auto t : type.expand()) {
       elements.push_back(make(t));
@@ -1764,7 +1764,7 @@ class TranslateToFuzzReader {
       }
       return builder.makeRefNull();
     }
-    if (type.isMulti()) {
+    if (type.isTuple()) {
       std::vector<Expression*> operands;
       for (auto t : type.expand()) {
         operands.push_back(makeConst(t));
@@ -1782,7 +1782,7 @@ class TranslateToFuzzReader {
   }
 
   Expression* makeUnary(Type type) {
-    assert(!type.isMulti());
+    assert(!type.isTuple());
     if (type == Type::unreachable) {
       if (auto* unary = makeUnary(getSingleConcreteType())->dynCast<Unary>()) {
         return builder.makeUnary(unary->op, make(Type::unreachable));
@@ -2003,7 +2003,7 @@ class TranslateToFuzzReader {
   }
 
   Expression* makeBinary(Type type) {
-    assert(!type.isMulti());
+    assert(!type.isTuple());
     if (type == Type::unreachable) {
       if (auto* binary =
             makeBinary(getSingleConcreteType())->dynCast<Binary>()) {

src/tools/wasm-reduce.cpp

@@ -1019,7 +1019,7 @@ struct Reducer
       RefNull* n = builder->makeRefNull();
       return tryToReplaceCurrent(n);
     }
-    if (curr->type.isMulti()) {
+    if (curr->type.isTuple()) {
       Expression* n =
         builder->makeConstantExpression(Literal::makeZero(curr->type));
       return tryToReplaceCurrent(n);

src/wasm-builder.h

@@ -795,7 +795,7 @@ class Builder {
   // minimal contents. as a replacement, this may reuse the
   // input node
   template<typename T> Expression* replaceWithIdenticalType(T* curr) {
-    if (curr->type.isMulti()) {
+    if (curr->type.isTuple()) {
       return makeConstantExpression(Literal::makeZero(curr->type));
     }
     Literal value;

src/wasm-type.h

@@ -26,21 +26,29 @@
 // Signature, Struct and Array types that will be single but not basic. To
 // prepare for this change, the following macro marks affected code locations.
 #define TODO_SINGLE_COMPOUND(type)                                             \
-  assert(!type.isMulti() && "Unexpected multi-value type");                    \
+  assert(!type.isTuple() && "Unexpected tuple type");                          \
   assert(!type.isCompound() && "TODO: handle compound types");
 
 namespace wasm {
 
+class Type;
+struct TypeDef;
+struct Tuple;
+struct Signature;
+struct Struct;
+struct Array;
+
+typedef std::vector<Type> TypeList;
+
 class Type {
   // The `id` uniquely represents each type, so type equality is just a
-  // comparison of the ids. For basic types the `id` is just the `ValueType`
+  // comparison of the ids. For basic types the `id` is just the `BasicID`
   // enum value below, and for constructed types the `id` is the address of the
   // canonical representation of the type, making lookups cheap for all types.
   uintptr_t id;
-  void init(const std::vector<Type>&);
 
 public:
-  enum ValueType : uint32_t {
+  enum BasicID : uint32_t {
     none,
     unreachable,
     i32,
@@ -52,24 +60,35 @@ class Type {
     externref,
     nullref,
     exnref,
-    _last_value_type = exnref
+    _last_basic_id = exnref
   };
 
   Type() = default;
 
-  // ValueType can be implicitly upgraded to Type
-  constexpr Type(ValueType id) : id(id){};
+  // BasicID can be implicitly upgraded to Type
+  constexpr Type(BasicID id) : id(id){};
 
   // But converting raw uint32_t is more dangerous, so make it explicit
   explicit Type(uint64_t id) : id(id){};
 
-  // Construct from lists of elementary types
-  Type(std::initializer_list<Type> types);
-  explicit Type(const std::vector<Type>& types);
+  // Construct tuple from a list of single types
+  Type(std::initializer_list<Type>);
+
+  // Construct from tuple description
+  explicit Type(const Tuple&);
+
+  // Construct from signature description
+  explicit Type(const Signature, bool nullable);
+
+  // Construct from struct description
+  explicit Type(const Struct&, bool nullable);
+
+  // Construct from array description
+  explicit Type(const Array&, bool nullable);
 
   // Accessors
   size_t size() const;
-  const std::vector<Type>& expand() const;
+  const TypeList& expand() const;
 
   // Predicates
   //                 Compound Concrete
@@ -89,30 +108,22 @@ class Type {
   // │ nullref     ║ x │   │ x │ x │       │ │
   // │ exnref      ║ x │   │ x │ x │       │ │
   // ├─────────────╫───┼───┼───┼───┤───────┤ │
-  // │ Signature   ║   │ x │ x │ x │ f     │ │ ┐
-  // │ Struct      ║   │ x │ x │ x │       │ │ │ TODO (GC)
-  // │ Array       ║   │ x │ x │ x │       │ ┘ ┘
-  // │ Multi       ║   │ x │   │ x │       │
+  // │ Signature   ║   │ x │ x │ x │ f     │ │
+  // │ Struct      ║   │ x │ x │ x │       │ │
+  // │ Array       ║   │ x │ x │ x │       │ ┘
+  // │ Tuple       ║   │ x │   │ x │       │
   // └─────────────╨───┴───┴───┴───┴───────┘
-  constexpr bool isBasic() const { return id <= _last_value_type; }
-  constexpr bool isCompound() const { return id > _last_value_type; }
-  constexpr bool isSingle() const {
-    // TODO: Compound types Signature, Struct and Array are single
-    return id >= i32 && id <= _last_value_type;
-  }
-  constexpr bool isMulti() const {
-    // TODO: Compound types Signature, Struct and Array are not multi
-    return id > _last_value_type;
-  }
+  constexpr bool isBasic() const { return id <= _last_basic_id; }
+  constexpr bool isCompound() const { return id > _last_basic_id; }
   constexpr bool isConcrete() const { return id >= i32; }
   constexpr bool isInteger() const { return id == i32 || id == i64; }
   constexpr bool isFloat() const { return id == f32 || id == f64; }
   constexpr bool isVector() const { return id == v128; };
   constexpr bool isNumber() const { return id >= i32 && id <= v128; }
-  constexpr bool isRef() const {
-    // TODO: Compound types Signature, Struct and Array are ref
-    return id >= funcref && id <= exnref;
-  }
+  bool isTuple() const;
+  bool isSingle() const { return isConcrete() && !isTuple(); }
+  bool isRef() const;
+  bool isNullable() const;
 
 private:
   template<bool (Type::*pred)() const> bool hasPredicate() {
@@ -129,18 +140,18 @@ class Type {
   bool hasRef() { return hasPredicate<&Type::isRef>(); }
 
   constexpr uint64_t getID() const { return id; }
-  constexpr ValueType getBasic() const {
+  constexpr BasicID getBasic() const {
     assert(isBasic() && "Basic type expected");
-    return static_cast<ValueType>(id);
+    return static_cast<BasicID>(id);
   }
 
-  // (In)equality must be defined for both Type and ValueType because it is
+  // (In)equality must be defined for both Type and BasicID because it is
   // otherwise ambiguous whether to convert both this and other to int or
   // convert other to Type.
   bool operator==(const Type& other) const { return id == other.id; }
-  bool operator==(const ValueType& other) const { return id == other; }
+  bool operator==(const BasicID& other) const { return id == other; }
   bool operator!=(const Type& other) const { return id != other.id; }
-  bool operator!=(const ValueType& other) const { return id != other; }
+  bool operator!=(const BasicID& other) const { return id != other; }
 
   // Order types by some notion of simplicity
   bool operator<(const Type& other) const;
@@ -193,6 +204,16 @@ struct ResultType {
   std::string toString() const;
 };
 
+struct Tuple {
+  TypeList types;
+  Tuple() : types() {}
+  Tuple(std::initializer_list<Type> types) : types(types) {}
+  Tuple(TypeList types) : types(types) {}
+  bool operator==(const Tuple& other) const { return types == other.types; }
+  bool operator!=(const Tuple& other) const { return !(*this == other); }
+  std::string toString() const;
+};
+
 struct Signature {
   Type params;
   Type results;
@@ -203,25 +224,91 @@ struct Signature {
   }
   bool operator!=(const Signature& other) const { return !(*this == other); }
   bool operator<(const Signature& other) const;
+  std::string toString() const;
 };
 
-std::ostream& operator<<(std::ostream& os, Type t);
-std::ostream& operator<<(std::ostream& os, ParamType t);
-std::ostream& operator<<(std::ostream& os, ResultType t);
-std::ostream& operator<<(std::ostream& os, Signature t);
+struct Field {
+  Type type;
+  enum PackedType {
+    not_packed,
+    i8,
+    i16,
+  } packedType; // applicable iff type=i32
+  bool mutable_;
+
+  Field(Type type, bool mutable_ = false)
+    : type(type), packedType(not_packed), mutable_(mutable_) {}
+  Field(PackedType packedType, bool mutable_ = false)
+    : type(Type::i32), packedType(packedType), mutable_(mutable_) {}
+
+  constexpr bool isPacked() const {
+    if (packedType != not_packed) {
+      assert(type == Type::i32 && "unexpected type");
+      return true;
+    }
+    return false;
+  }
+
+  bool operator==(const Field& other) const {
+    return type == other.type && packedType == other.packedType &&
+           mutable_ == other.mutable_;
+  }
+  bool operator!=(const Field& other) const { return !(*this == other); }
+  std::string toString() const;
+};
+
+typedef std::vector<Field> FieldList;
+
+struct Struct {
+  FieldList fields;
+  Struct(const Struct& other) : fields(other.fields) {}
+  Struct(FieldList fields) : fields(fields) {}
+  bool operator==(const Struct& other) const { return fields == other.fields; }
+  bool operator!=(const Struct& other) const { return !(*this == other); }
+  std::string toString() const;
+};
+
+struct Array {
+  Field element;
+  Array(const Array& other) : element(other.element) {}
+  Array(Field element) : element(element) {}
+  bool operator==(const Array& other) const { return element == other.element; }
+  bool operator!=(const Array& other) const { return !(*this == other); }
+  std::string toString() const;
+};
+
+std::ostream& operator<<(std::ostream&, Type);
+std::ostream& operator<<(std::ostream&, ParamType);
+std::ostream& operator<<(std::ostream&, ResultType);
+std::ostream& operator<<(std::ostream&, Tuple);
+std::ostream& operator<<(std::ostream&, Signature);
+std::ostream& operator<<(std::ostream&, Field);
+std::ostream& operator<<(std::ostream&, Struct);
+std::ostream& operator<<(std::ostream&, Array);
+std::ostream& operator<<(std::ostream&, TypeDef);
 
 } // namespace wasm
 
 namespace std {
 
 template<> class hash<wasm::Type> {
 public:
-  size_t operator()(const wasm::Type& type) const;
+  size_t operator()(const wasm::Type&) const;
 };
 
 template<> class hash<wasm::Signature> {
 public:
-  size_t operator()(const wasm::Signature& sig) const;
+  size_t operator()(const wasm::Signature&) const;
+};
+
+template<> class hash<wasm::Field> {
+public:
+  size_t operator()(const wasm::Field&) const;
+};
+
+template<> class hash<wasm::TypeDef> {
+public:
+  size_t operator()(const wasm::TypeDef&) const;
 };
 
 } // namespace std

src/wasm/literal.cpp

@@ -1435,8 +1435,7 @@ Literal Literal::shuffleV8x16(const Literal& other,
   return Literal(bytes);
 }
 
-template<Type::ValueType Ty, int Lanes>
-static Literal splat(const Literal& val) {
+template<Type::BasicID Ty, int Lanes> static Literal splat(const Literal& val) {
   assert(val.type == Ty);
   LaneArray<Lanes> lanes;
   lanes.fill(val);