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

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

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/wasm/asm-types.h"
 
 #include <unordered_map>
 #include <unordered_set>
 
 #include "src/base/macros.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 namespace {
 
 using ::testing::StrEq;
 
 class AsmTypeTest : public TestWithZone {
  public:
   using Type = AsmType;
 
   AsmTypeTest()
       : parents_({
             {Type::Uint8Array(), {Type::Heap()}},
             {Type::Int8Array(), {Type::Heap()}},
+            {Type::Uint8ClampedArray(), {Type::Heap()}},
             {Type::Uint16Array(), {Type::Heap()}},
             {Type::Int16Array(), {Type::Heap()}},
             {Type::Uint32Array(), {Type::Heap()}},
             {Type::Int32Array(), {Type::Heap()}},
             {Type::Float32Array(), {Type::Heap()}},
             {Type::Float64Array(), {Type::Heap()}},
             {Type::FloatishDoubleQ(), {Type::Floatish(), Type::DoubleQ()}},
             {Type::FloatQDoubleQ(),
              {Type::FloatQ(), Type::Floatish(), Type::DoubleQ()}},
             {Type::Float(), {Type::FloatQ(), Type::Floatish()}},
@@ skipping 102 matching lines @@
 TEST_F(AsmTypeTest, ValidateBits) {
   // Generic validation tests for the bits in the type system's type
   // definitions.
 
   std::unordered_set<Type*> seen_types;
   std::unordered_set<uint32_t> seen_numbers;
   uint32_t total_types = 0;
 #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. */                           \
     EXPECT_NE(0, number) << Type::CamelName()->Name();                       \
     /* Inheritance cycles - unlikely, but we're paranoid and check for it */ \
     /* anyways.*/                                                            \
     EXPECT_EQ(0, (1 << (number)) & AsmValueTypeParents::CamelName);          \
   } while (0);
   FOR_EACH_ASM_VALUE_TYPE_LIST(V)
 #undef V
@@ skipping 47 matching lines @@
 #undef V
 
   EXPECT_THAT(Function(Type::Int)(Type::Double, Type::Float)->Name(),
               StrEq("(double, float) -> int"));
 
   EXPECT_THAT(Overload(Function(Type::Int)(Type::Double, Type::Float),
                        Function(Type::Int)(Type::Int))
                   ->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::FroundType(zone())->Name(), StrEq("fround"));
 
-  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::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) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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) {
     for (size_t jj = 0; jj < arraysize(test_types); ++jj) {
       EXPECT_EQ(ii == jj, test_types[ii]->IsExactly(test_types[jj]))
           << test_types[ii]->Name()
           << ((ii == jj) ? " is not exactly " : " is exactly ")
           << test_types[jj]->Name();
     }
   }
 }
 
 TEST_F(AsmTypeTest, IsA) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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) {
     for (size_t jj = 0; jj < arraysize(test_types); ++jj) {
       const bool Expected =
           (ii == jj) || ParentsOf(test_types[ii]).count(test_types[jj]) != 0;
       EXPECT_EQ(Expected, test_types[ii]->IsA(test_types[jj]))
           << test_types[ii]->Name() << (Expected ? " is not a " : " is a ")
           << test_types[jj]->Name();
     }
   }
 }
 
 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);
+  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::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));
+  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());
+  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 =
       Function(Type::Double)(Type::Double, Type::Double, Type::Double);
   auto* dddd2d = Function(Type::Double)(Type::Double, Type::Double,
                                         Type::Double, Type::Double);
   EXPECT_EQ(Type::Double(),
             min_max_double->AsCallableType()->ValidateCall(min_max_double));
   EXPECT_EQ(Type::Double(),
             min_max_double->AsCallableType()->ValidateCall(dd2d));
   EXPECT_EQ(Type::Double(),
             min_max_double->AsCallableType()->ValidateCall(ddd2d));
   EXPECT_EQ(Type::Double(),
             min_max_double->AsCallableType()->ValidateCall(dddd2d));
   EXPECT_EQ(Type::None(), min_max_double->AsCallableType()->ValidateCall(d2d));
 
   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)));
   EXPECT_EQ(Type::Float(), fround->AsCallableType()->ValidateCall(
                                Function(Type::Float)(Type::FloatQ)));
   EXPECT_EQ(Type::Float(), fround->AsCallableType()->ValidateCall(
                                Function(Type::Float)(Type::Float)));
   EXPECT_EQ(Type::Float(), fround->AsCallableType()->ValidateCall(
                                Function(Type::Float)(Type::DoubleQ)));
   EXPECT_EQ(Type::Float(), fround->AsCallableType()->ValidateCall(
@@ skipping 22 matching lines @@
 
 TEST_F(AsmTypeTest, IsReturnType) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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{
       Type::Double(), Type::Signed(), Type::Float(), Type::Void(),
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
     const bool IsReturnType = return_types.count(test_types[ii]);
     EXPECT_EQ(IsReturnType, test_types[ii]->IsReturnType())
         << test_types[ii]->Name()
         << (IsReturnType ? " is not a return type" : " is a return type");
   }
 }
 
 TEST_F(AsmTypeTest, IsParameterType) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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{
       Type::Double(), Type::Int(), Type::Float(),
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
     const bool IsParameterType = parameter_types.count(test_types[ii]);
     EXPECT_EQ(IsParameterType, test_types[ii]->IsParameterType())
         << test_types[ii]->Name()
         << (IsParameterType ? " is not a parameter type"
                             : " is a parameter type");
   }
 }
 
 TEST_F(AsmTypeTest, IsComparableType) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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{
       Type::Double(), Type::Signed(), Type::Unsigned(), Type::Float(),
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
     const bool IsComparableType = comparable_types.count(test_types[ii]);
     EXPECT_EQ(IsComparableType, test_types[ii]->IsComparableType())
         << test_types[ii]->Name()
         << (IsComparableType ? " is not a comparable type"
                              : " is a comparable type");
   }
 }
 
 TEST_F(AsmTypeTest, ElementSizeInBytes) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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 {
-    if (type == Type::Int8Array() || type == Type::Uint8Array()) {
+    if (type == Type::Int8Array() || type == Type::Uint8Array() ||
+        type == Type::Uint8ClampedArray()) {
       return 1;
     }
     if (type == Type::Int16Array() || type == Type::Uint16Array()) {
       return 2;
     }
     if (type == Type::Int32Array() || type == Type::Uint32Array() ||
         type == Type::Float32Array()) {
       return 4;
     }
     if (type == Type::Float64Array()) {
@@ skipping 10 matching lines @@
 
 TEST_F(AsmTypeTest, LoadType) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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* {
     if (type == Type::Int8Array() || type == Type::Uint8Array() ||
-        type == Type::Int16Array() || type == Type::Uint16Array() ||
-        type == Type::Int32Array() || type == Type::Uint32Array()) {
+        type == Type::Uint8ClampedArray() || type == Type::Int16Array() ||
+        type == Type::Uint16Array() || type == Type::Int32Array() ||
+        type == Type::Uint32Array()) {
       return Type::Intish();
     }
 
     if (type == Type::Float32Array()) {
       return Type::FloatQ();
     }
 
     if (type == Type::Float64Array()) {
       return Type::DoubleQ();
     }
 
     return Type::None();
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
     EXPECT_EQ(LoadTypeForType(test_types[ii]), test_types[ii]->LoadType());
   }
 }
 
 TEST_F(AsmTypeTest, StoreType) {
   Type* test_types[] = {
 #define CREATE(CamelName, string_name, number, parent_types) Type::CamelName(),
       FOR_EACH_ASM_VALUE_TYPE_LIST(CREATE)
 #undef CREATE
           Function(Type::Int)(Type::Double),
       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* {
     if (type == Type::Int8Array() || type == Type::Uint8Array() ||
-        type == Type::Int16Array() || type == Type::Uint16Array() ||
-        type == Type::Int32Array() || type == Type::Uint32Array()) {
+        type == Type::Uint8ClampedArray() || type == Type::Int16Array() ||
+        type == Type::Uint16Array() || type == Type::Int32Array() ||
+        type == Type::Uint32Array()) {
       return Type::Intish();
     }
 
     if (type == Type::Float32Array()) {
       return Type::FloatishDoubleQ();
     }
 
     if (type == Type::Float64Array()) {
       return Type::FloatQDoubleQ();
     }
 
     return Type::None();
   };
 
   for (size_t ii = 0; ii < arraysize(test_types); ++ii) {
     EXPECT_EQ(StoreTypeForType(test_types[ii]), test_types[ii]->StoreType())
         << test_types[ii]->Name();
   }
 }
 
 }  // namespace
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8