V8. ASM-2-WASM. Changes the asm-types library.

The modifications were necessary to properly represent asm types:

1) fround is no longer an overloaded function.

2) the constructor for MinMaxTypes now takes a return type.

3) Adds pseudo-types for representing the Load/Store types for fp heap views.
BUG=

Review-Url: https://codereview.chromium.org/2069443002
Cr-Commit-Position: refs/heads/master@{#36980}

src/wasm/asm-types.cc

@@ -29,6 +29,7 @@ std::string AsmType::Name() {
         UNREACHABLE();
     }
   }
+
   return this->AsCallableType()->Name();
 }
 
@@ -42,6 +43,7 @@ bool AsmType::IsExactly(AsmType* that) {
     }
     return avt->Bitset() == tavt->Bitset();
   }
+
   // TODO(jpp): is it useful to allow non-value types to be tested with
   // IsExactly?
   return that == this;
@@ -58,6 +60,7 @@ bool AsmType::IsA(AsmType* that) {
     }
     return (avt->Bitset() & tavt->Bitset()) == tavt->Bitset();
   }
+
   // TODO(jpp): is it useful to allow non-value types to be tested with IsA?
   return that == this;
 }
@@ -130,6 +133,10 @@ AsmType* AsmType::StoreType() {
 }
 
 std::string AsmFunctionType::Name() {
+  if (IsFroundType()) {
+    return "fround";
+  }
+
   std::string ret;
   ret += "(";
   for (size_t ii = 0; ii < args_.size(); ++ii) {
@@ -155,19 +162,33 @@ class AsmFroundType final : public AsmFunctionType {
  private:
   friend AsmType;
 
-  AsmFroundType(Zone* zone, AsmType* src)
-      : AsmFunctionType(zone, AsmType::Float()) {
-    AddArgument(src);
-  }
+  explicit AsmFroundType(Zone* zone)
+      : AsmFunctionType(zone, AsmType::Float()) {}
+
+  AsmType* ValidateCall(AsmType* function_type) override;
 };
 }  // namespace
 
-AsmType* AsmType::FroundType(Zone* zone, AsmType* src) {
-  DCHECK(src->AsValueType() != nullptr);
-  auto* Fround = new (zone) AsmFroundType(zone, src);
+AsmType* AsmType::FroundType(Zone* zone) {
+  auto* Fround = new (zone) AsmFroundType(zone);
   return reinterpret_cast<AsmType*>(Fround);
 }
 
+AsmType* AsmFroundType::ValidateCall(AsmType* function_type) {
+  auto* callable = function_type->AsFunctionType();
+  if (callable->Arguments().size() != 1) {
+    return AsmType::None();
+  }
+
+  auto* arg = callable->Arguments()[0];
+  if (!arg->IsA(AsmType::Floatish()) && !arg->IsA(AsmType::DoubleQ()) &&
+      !arg->IsA(AsmType::Signed()) && !arg->IsA(AsmType::Unsigned())) {
+    return AsmType::None();
+  }
+
+  return AsmType::Float();
+}
+
 namespace {
 class AsmMinMaxType final : public AsmFunctionType {
  public:
@@ -176,9 +197,10 @@ class AsmMinMaxType final : public AsmFunctionType {
  private:
   friend AsmType;
 
-  AsmMinMaxType(Zone* zone, AsmType* type) : AsmFunctionType(zone, type) {
-    AddArgument(type);
-    AddArgument(type);
+  AsmMinMaxType(Zone* zone, AsmType* dest, AsmType* src)
+      : AsmFunctionType(zone, dest) {
+    AddArgument(src);
+    AddArgument(src);
   }
 
   AsmType* ValidateCall(AsmType* function_type) override {
@@ -206,9 +228,10 @@ class AsmMinMaxType final : public AsmFunctionType {
 };
 }  // namespace
 
-AsmType* AsmType::MinMaxType(Zone* zone, AsmType* type) {
-  DCHECK(type->AsValueType() != nullptr);
-  auto* MinMax = new (zone) AsmMinMaxType(zone, type);
+AsmType* AsmType::MinMaxType(Zone* zone, AsmType* dest, AsmType* src) {
+  DCHECK(dest->AsValueType() != nullptr);
+  DCHECK(src->AsValueType() != nullptr);
+  auto* MinMax = new (zone) AsmMinMaxType(zone, dest, src);
   return reinterpret_cast<AsmType*>(MinMax);
 }
 

src/wasm/asm-types.h

@@ -6,7 +6,6 @@
 #define SRC_WASM_ASM_TYPES_H_
 
 #include <string>
-#include <type_traits>
 
 #include "src/base/macros.h"
 #include "src/zone-containers.h"
@@ -47,8 +46,9 @@ class AsmOverloadedFunctionType;
   V(Int32Array, "Int32Array", 19, kAsmHeap)                                   \
   V(Float32Array, "Float32Array", 20, kAsmHeap)                               \
   V(Float64Array, "Float64Array", 21, kAsmHeap)                               \
-  V(FloatishDoubleQ, "floatish|double?", 22, kAsmFloatish | kAsmDoubleQ)      \
-  V(FloatQDoubleQ, "float?|double?", 23, kAsmFloatQ | kAsmDoubleQ)            \
+  /* Pseudo-types used in representing heap access for fp types.*/            \
+  V(FloatishDoubleQ, "floatish|double?", 23, kAsmFloatish | kAsmDoubleQ)      \
+  V(FloatQDoubleQ, "float?|double?", 24, kAsmFloatQ | kAsmDoubleQ)            \
   /* None is used to represent errors in the type checker. */                 \
   V(None, "<none>", 31, 0)
 
@@ -200,10 +200,10 @@ class AsmType {
   }
 
   // The type for fround(src).
-  static AsmType* FroundType(Zone* zone, AsmType* src);
+  static AsmType* FroundType(Zone* zone);
 
   // The (variadic) type for min and max.
-  static AsmType* MinMaxType(Zone* zone, AsmType* type);
+  static AsmType* MinMaxType(Zone* zone, AsmType* dest, AsmType* src);
 
   std::string Name();
   // IsExactly returns true if this is the exact same type as that. For

test/unittests/wasm/asm-types-unittest.cc

@@ -149,6 +149,9 @@ TEST_F(AsmTypeTest, ValidateBits) {
 #define V(CamelName, string_name, number, parent_types)                      \
   do {                                                                       \
     ++total_types;                                                           \
+    if (AsmValueTypeParents::CamelName != 0) {                               \
+      EXPECT_NE(0, ParentsOf(AsmType::CamelName()).size()) << #CamelName;    \
+    }                                                                        \
     seen_types.insert(Type::CamelName());                                    \
     seen_numbers.insert(number);                                             \
     /* Every ASM type must have a valid number. */                           \
@@ -216,19 +219,14 @@ TEST_F(AsmTypeTest, Names) {
                   ->Name(),
               StrEq("(double, float) -> int /\\ (int) -> int"));
 
-  EXPECT_THAT(Type::FroundType(zone(), Type::Int())->Name(),
-              StrEq("(int) -> float"));
-  EXPECT_THAT(Type::FroundType(zone(), Type::Floatish())->Name(),
-              StrEq("(floatish) -> float"));
-  EXPECT_THAT(Type::FroundType(zone(), Type::DoubleQ())->Name(),
-              StrEq("(double?) -> float"));
-
-  EXPECT_THAT(Type::MinMaxType(zone(), Type::Int())->Name(),
-              StrEq("(int, int...) -> int"));
-  EXPECT_THAT(Type::MinMaxType(zone(), Type::Floatish())->Name(),
-              StrEq("(floatish, floatish...) -> floatish"));
-  EXPECT_THAT(Type::MinMaxType(zone(), Type::DoubleQ())->Name(),
-              StrEq("(double?, double?...) -> double?"));
+  EXPECT_THAT(Type::FroundType(zone())->Name(), StrEq("fround"));
+
+  EXPECT_THAT(Type::MinMaxType(zone(), Type::Signed(), Type::Int())->Name(),
+              StrEq("(int, int...) -> signed"));
+  EXPECT_THAT(Type::MinMaxType(zone(), Type::Float(), Type::Floatish())->Name(),
+              StrEq("(floatish, floatish...) -> float"));
+  EXPECT_THAT(Type::MinMaxType(zone(), Type::Double(), Type::Double())->Name(),
+              StrEq("(double, double...) -> double"));
 }
 
 TEST_F(AsmTypeTest, IsExactly) {
@@ -240,8 +238,8 @@ TEST_F(AsmTypeTest, IsExactly) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
@@ -263,8 +261,8 @@ TEST_F(AsmTypeTest, IsA) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
@@ -279,21 +277,23 @@ TEST_F(AsmTypeTest, IsA) {
 }
 
 TEST_F(AsmTypeTest, ValidateCall) {
-  auto* min_max_int = Type::MinMaxType(zone(), Type::Int());
-  auto* i2i = Function(Type::Int)(Type::Int);
-  auto* ii2i = Function(Type::Int)(Type::Int, Type::Int);
-  auto* iii2i = Function(Type::Int)(Type::Int, Type::Int, Type::Int);
-  auto* iiii2i =
-      Function(Type::Int)(Type::Int, Type::Int, Type::Int, Type::Int);
-
-  EXPECT_EQ(Type::Int(),
+  auto* min_max_int = Type::MinMaxType(zone(), Type::Signed(), Type::Int());
+  auto* i2s = Function(Type::Signed)(Type::Int);
+  auto* ii2s = Function(Type::Signed)(Type::Int, Type::Int);
+  auto* iii2s = Function(Type::Signed)(Type::Int, Type::Int, Type::Int);
+  auto* iiii2s =
+      Function(Type::Signed)(Type::Int, Type::Int, Type::Int, Type::Int);
+
+  EXPECT_EQ(Type::Signed(),
             min_max_int->AsCallableType()->ValidateCall(min_max_int));
-  EXPECT_EQ(Type::Int(), min_max_int->AsCallableType()->ValidateCall(ii2i));
-  EXPECT_EQ(Type::Int(), min_max_int->AsCallableType()->ValidateCall(iii2i));
-  EXPECT_EQ(Type::Int(), min_max_int->AsCallableType()->ValidateCall(iiii2i));
-  EXPECT_EQ(Type::None(), min_max_int->AsCallableType()->ValidateCall(i2i));
-
-  auto* min_max_double = Type::MinMaxType(zone(), Type::Double());
+  EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(ii2s));
+  EXPECT_EQ(Type::Signed(), min_max_int->AsCallableType()->ValidateCall(iii2s));
+  EXPECT_EQ(Type::Signed(),
+            min_max_int->AsCallableType()->ValidateCall(iiii2s));
+  EXPECT_EQ(Type::None(), min_max_int->AsCallableType()->ValidateCall(i2s));
+
+  auto* min_max_double =
+      Type::MinMaxType(zone(), Type::Double(), Type::Double());
   auto* d2d = Function(Type::Double)(Type::Double);
   auto* dd2d = Function(Type::Double)(Type::Double, Type::Double);
   auto* ddd2d =
@@ -312,29 +312,20 @@ TEST_F(AsmTypeTest, ValidateCall) {
 
   auto* min_max = Overload(min_max_int, min_max_double);
   EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(min_max));
-  EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(i2i));
+  EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(i2s));
   EXPECT_EQ(Type::None(), min_max->AsCallableType()->ValidateCall(d2d));
-  EXPECT_EQ(Type::Int(), min_max->AsCallableType()->ValidateCall(min_max_int));
-  EXPECT_EQ(Type::Int(), min_max->AsCallableType()->ValidateCall(ii2i));
-  EXPECT_EQ(Type::Int(), min_max->AsCallableType()->ValidateCall(iii2i));
-  EXPECT_EQ(Type::Int(), min_max->AsCallableType()->ValidateCall(iiii2i));
+  EXPECT_EQ(Type::Signed(),
+            min_max->AsCallableType()->ValidateCall(min_max_int));
+  EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(ii2s));
+  EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(iii2s));
+  EXPECT_EQ(Type::Signed(), min_max->AsCallableType()->ValidateCall(iiii2s));
   EXPECT_EQ(Type::Double(),
             min_max->AsCallableType()->ValidateCall(min_max_double));
   EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(dd2d));
   EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(ddd2d));
   EXPECT_EQ(Type::Double(), min_max->AsCallableType()->ValidateCall(dddd2d));
 
-  auto* fround_floatish = Type::FroundType(zone(), Type::Floatish());
-  auto* fround_floatq = Type::FroundType(zone(), Type::FloatQ());
-  auto* fround_float = Type::FroundType(zone(), Type::Float());
-  auto* fround_doubleq = Type::FroundType(zone(), Type::DoubleQ());
-  auto* fround_double = Type::FroundType(zone(), Type::Double());
-  auto* fround_signed = Type::FroundType(zone(), Type::Signed());
-  auto* fround_unsigned = Type::FroundType(zone(), Type::Unsigned());
-  auto* fround_fixnum = Type::FroundType(zone(), Type::FixNum());
-  auto* fround =
-      Overload(fround_floatish, fround_floatq, fround_float, fround_doubleq,
-               fround_double, fround_signed, fround_unsigned, fround_fixnum);
+  auto* fround = Type::FroundType(zone());
 
   EXPECT_EQ(Type::Float(), fround->AsCallableType()->ValidateCall(
                                Function(Type::Float)(Type::Floatish)));
@@ -377,8 +368,8 @@ TEST_F(AsmTypeTest, IsReturnType) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   std::unordered_set<Type*> return_types{
@@ -402,8 +393,8 @@ TEST_F(AsmTypeTest, IsParameterType) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   std::unordered_set<Type*> parameter_types{
@@ -428,8 +419,8 @@ TEST_F(AsmTypeTest, IsComparableType) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   std::unordered_set<Type*> comparable_types{
@@ -454,8 +445,8 @@ TEST_F(AsmTypeTest, ElementSizeInBytes) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   auto ElementSizeInBytesForType = [](Type* type) -> int32_t {
@@ -490,8 +481,8 @@ TEST_F(AsmTypeTest, LoadType) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   auto LoadTypeForType = [](Type* type) -> Type* {
@@ -526,8 +517,8 @@ TEST_F(AsmTypeTest, StoreType) {
       Function(Type::Int)(Type::DoubleQ),
       Overload(Function(Type::Int)(Type::Double)),
       Function(Type::Int)(Type::Int, Type::Int),
-      Type::MinMaxType(zone(), Type::Int()), Function(Type::Int)(Type::Float),
-      Type::FroundType(zone(), Type::Int()),
+      Type::MinMaxType(zone(), Type::Signed(), Type::Int()),
+      Function(Type::Int)(Type::Float), Type::FroundType(zone()),
   };
 
   auto StoreTypeForType = [](Type* type) -> Type* {