V8. ASM-2-WASM. New type system.

This CL introduces the new type system for the ASM
type-checker/validator.

BUG=

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

BUILD.gn

@@ -1492,6 +1492,8 @@ v8_source_set("v8_base") {
     "src/version.h",
     "src/vm-state-inl.h",
     "src/vm-state.h",
+    "src/wasm/asm-types.cc",
+    "src/wasm/asm-types.h",
     "src/wasm/asm-wasm-builder.cc",
     "src/wasm/asm-wasm-builder.h",
     "src/wasm/ast-decoder.cc",

src/v8.gyp

@@ -1147,6 +1147,8 @@
         'version.h',
         'vm-state-inl.h',
         'vm-state.h',
+        'wasm/asm-types.cc',
+        'wasm/asm-types.h',
         'wasm/asm-wasm-builder.cc',
         'wasm/asm-wasm-builder.h',
         'wasm/ast-decoder.cc',

src/wasm/asm-types.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/v8.h"
+
+#include "src/wasm/asm-types.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+AsmCallableType* AsmType::AsCallableType() {
+  DCHECK(this->AsFunctionType() != nullptr ||
+         this->AsOverloadedFunctionType() != nullptr);
+  return reinterpret_cast<AsmCallableType*>(this);
+}
+
+std::string AsmType::Name() {
+  AsmValueType* avt = this->AsValueType();
+  if (avt != nullptr) {
+    switch (avt->Bitset()) {
+#define RETURN_TYPE_NAME(CamelName, string_name, number, parent_types) \
+  case AsmValueType::kAsm##CamelName:                                  \
+    return string_name;
+      FOR_EACH_ASM_VALUE_TYPE_LIST(RETURN_TYPE_NAME)
+#undef RETURN_TYPE_NAME
+      default:
+        UNREACHABLE();
+    }
+  }
+  return this->AsCallableType()->Name();
+}
+
+bool AsmType::IsExactly(AsmType* that) {
+  // TODO(jpp): maybe this can become this == that.
+  AsmValueType* avt = this->AsValueType();
+  if (avt != nullptr) {
+    AsmValueType* tavt = that->AsValueType();
+    if (tavt == nullptr) {
+      return false;
+    }
+    return avt->Bitset() == tavt->Bitset();
+  }
+  // TODO(jpp): is it useful to allow non-value types to be tested with
+  // IsExactly?
+  return that == this;
+}
+
+bool AsmType::IsA(AsmType* that) {
+  // IsA is used for querying inheritance relationships. Therefore it is only
+  // meaningful for basic types.
+  AsmValueType* tavt = that->AsValueType();
+  if (tavt != nullptr) {
+    AsmValueType* avt = this->AsValueType();
+    if (avt == nullptr) {
+      return false;
+    }
+    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;
+}
+
+int32_t AsmType::ElementSizeInBytes() {
+  auto* value = AsValueType();
+  if (value == nullptr) {
+    return AsmType::kNotHeapType;
+  }
+  switch (value->Bitset()) {
+    case AsmValueType::kAsmInt8Array:
+    case AsmValueType::kAsmUint8Array:
+      return 1;
+    case AsmValueType::kAsmInt16Array:
+    case AsmValueType::kAsmUint16Array:
+      return 2;
+    case AsmValueType::kAsmInt32Array:
+    case AsmValueType::kAsmUint32Array:
+    case AsmValueType::kAsmFloat32Array:
+      return 4;
+    case AsmValueType::kAsmFloat64Array:
+      return 8;
+    default:
+      return AsmType::kNotHeapType;
+  }
+}
+
+AsmType* AsmType::LoadType() {
+  auto* value = AsValueType();
+  if (value == nullptr) {
+    return AsmType::None();
+  }
+  switch (value->Bitset()) {
+    case AsmValueType::kAsmInt8Array:
+    case AsmValueType::kAsmUint8Array:
+    case AsmValueType::kAsmInt16Array:
+    case AsmValueType::kAsmUint16Array:
+    case AsmValueType::kAsmInt32Array:
+    case AsmValueType::kAsmUint32Array:
+      return AsmType::Intish();
+    case AsmValueType::kAsmFloat32Array:
+      return AsmType::FloatQ();
+    case AsmValueType::kAsmFloat64Array:
+      return AsmType::DoubleQ();
+    default:
+      return AsmType::None();
+  }
+}
+
+AsmType* AsmType::StoreType() {
+  auto* value = AsValueType();
+  if (value == nullptr) {
+    return AsmType::None();
+  }
+  switch (value->Bitset()) {
+    case AsmValueType::kAsmInt8Array:
+    case AsmValueType::kAsmUint8Array:
+    case AsmValueType::kAsmInt16Array:
+    case AsmValueType::kAsmUint16Array:
+    case AsmValueType::kAsmInt32Array:
+    case AsmValueType::kAsmUint32Array:
+      return AsmType::Intish();
+    case AsmValueType::kAsmFloat32Array:
+      return AsmType::FloatishDoubleQ();
+    case AsmValueType::kAsmFloat64Array:
+      return AsmType::FloatQDoubleQ();
+    default:
+      return AsmType::None();
+  }
+}
+
+std::string AsmFunctionType::Name() {
+  std::string ret;
+  ret += "(";
+  for (size_t ii = 0; ii < args_.size(); ++ii) {
+    ret += args_[ii]->Name();
+    if (ii != args_.size() - 1) {
+      ret += ", ";
+    }
+  }
+  if (IsMinMaxType()) {
+    DCHECK_EQ(args_.size(), 2);
+    ret += "...";
+  }
+  ret += ") -> ";
+  ret += return_type_->Name();
+  return ret;
+}
+
+namespace {
+class AsmFroundType final : public AsmFunctionType {
+ public:
+  bool IsFroundType() const override { return true; }
+
+ private:
+  friend AsmType;
+
+  AsmFroundType(Zone* zone, AsmType* src)
+      : AsmFunctionType(zone, AsmType::Float()) {
+    AddArgument(src);
+  }
+};
+}  // namespace
+
+AsmType* AsmType::FroundType(Zone* zone, AsmType* src) {
+  DCHECK(src->AsValueType() != nullptr);
+  auto* Fround = new (zone) AsmFroundType(zone, src);
+  return reinterpret_cast<AsmType*>(Fround);
+}
+
+namespace {
+class AsmMinMaxType final : public AsmFunctionType {
+ public:
+  bool IsMinMaxType() const override { return true; }
+
+ private:
+  friend AsmType;
+
+  AsmMinMaxType(Zone* zone, AsmType* type) : AsmFunctionType(zone, type) {
+    AddArgument(type);
+    AddArgument(type);
+  }
+
+  AsmType* ValidateCall(AsmType* function_type) override {
+    auto* callable = function_type->AsFunctionType();
+    if (callable == nullptr) {
+      return nullptr;
+    }
+
+    if (!ReturnType()->IsExactly(callable->ReturnType())) {
+      return AsmType::None();
+    }
+
+    if (callable->Arguments().size() < 2) {
+      return AsmType::None();
+    }
+
+    for (size_t ii = 0; ii < Arguments().size(); ++ii) {
+      if (!Arguments()[0]->IsExactly(callable->Arguments()[ii])) {
+        return AsmType::None();
+      }
+    }
+
+    return ReturnType();
+  }
+};
+}  // namespace
+
+AsmType* AsmType::MinMaxType(Zone* zone, AsmType* type) {
+  DCHECK(type->AsValueType() != nullptr);
+  auto* MinMax = new (zone) AsmMinMaxType(zone, type);
+  return reinterpret_cast<AsmType*>(MinMax);
+}
+
+AsmType* AsmFunctionType::ValidateCall(AsmType* function_type) {
+  auto* callable = function_type->AsFunctionType();
+  if (callable == nullptr) {
+    return nullptr;
+  }
+
+  if (!return_type_->IsExactly(callable->return_type_)) {
+    return AsmType::None();
+  }
+
+  if (args_.size() != callable->args_.size()) {
+    return AsmType::None();
+  }
+
+  for (size_t ii = 0; ii < args_.size(); ++ii) {
+    if (!args_[ii]->IsExactly(callable->args_[ii])) {
+      return AsmType::None();
+    }
+  }
+
+  return return_type_;
+}
+
+std::string AsmOverloadedFunctionType::Name() {
+  std::string ret;
+
+  for (size_t ii = 0; ii < overloads_.size(); ++ii) {
+    if (ii != 0) {
+      ret += " /\\ ";
+    }
+    ret += overloads_[ii]->Name();
+  }
+
+  return ret;
+}
+
+AsmType* AsmOverloadedFunctionType::ValidateCall(AsmType* function_type) {
+  auto* callable = function_type->AsFunctionType();
+  if (callable == nullptr) {
+    return AsmType::None();
+  }
+
+  for (size_t ii = 0; ii < overloads_.size(); ++ii) {
+    auto* validated_type =
+        overloads_[ii]->AsCallableType()->ValidateCall(function_type);
+    if (validated_type != AsmType::None()) {
+      return validated_type;
+    }
+  }
+
+  return AsmType::None();
+}
+
+void AsmOverloadedFunctionType::AddOverload(AsmType* overload) {
+  DCHECK(overload->AsFunctionType() != nullptr);
+  overloads_.push_back(overload);
+}
+
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8

src/wasm/asm-types.h

+// 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.
+
+#ifndef SRC_WASM_ASM_TYPES_H_
+#define SRC_WASM_ASM_TYPES_H_
+
+#include <string>
+#include <type_traits>
+
+#include "src/base/macros.h"
+#include "src/zone-containers.h"
+#include "src/zone.h"
+
+namespace v8 {
+namespace internal {
+namespace wasm {
+
+class AsmType;
+class AsmFunctionType;
+class AsmOverloadedFunctionType;
+
+// List of V(CamelName, string_name, number, parent_types)
+#define FOR_EACH_ASM_VALUE_TYPE_LIST(V)                                       \
+  /* These tags are not types that are expressable in the asm source. They */ \
+  /* are used to express semantic information about the types they tag.    */ \
+  V(Heap, "[]", 1, 0)                                                         \
+  /*The following are actual types that appear in the asm source. */          \
+  V(Void, "void", 2, 0)                                                       \
+  V(Extern, "extern", 3, 0)                                                   \
+  V(DoubleQ, "double?", 4, 0)                                                 \
+  V(Double, "double", 5, kAsmDoubleQ | kAsmExtern)                            \
+  V(Intish, "intish", 6, 0)                                                   \
+  V(Int, "int", 7, kAsmIntish)                                                \
+  V(Signed, "signed", 8, kAsmInt | kAsmExtern)                                \
+  V(Unsigned, "unsigned", 9, kAsmInt)                                         \
+  V(FixNum, "fixnum", 10, kAsmSigned | kAsmUnsigned)                          \
+  V(Floatish, "floatish", 11, 0)                                              \
+  V(FloatQ, "float?", 12, kAsmFloatish)                                       \
+  V(Float, "float", 13, kAsmFloatQ)                                           \
+  /* Types used for expressing the Heap accesses. */                          \
+  V(Uint8Array, "Uint8Array", 14, kAsmHeap)                                   \
+  V(Int8Array, "Int8Array", 15, kAsmHeap)                                     \
+  V(Uint16Array, "Uint16Array", 16, kAsmHeap)                                 \
+  V(Int16Array, "Int16Array", 17, kAsmHeap)                                   \
+  V(Uint32Array, "Uint32Array", 18, kAsmHeap)                                 \
+  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)            \
+  /* None is used to represent errors in the type checker. */                 \
+  V(None, "<none>", 31, 0)
+
+// List of V(CamelName)
+#define FOR_EACH_ASM_CALLABLE_TYPE_LIST(V) \
+  V(FunctionType)                          \
+  V(OverloadedFunctionType)
+
+class AsmValueType {
+ public:
+  typedef uint32_t bitset_t;
+
+  enum : uint32_t {
+#define DEFINE_TAG(CamelName, string_name, number, parent_types) \
+  kAsm##CamelName = ((1u << (number)) | (parent_types)),
+    FOR_EACH_ASM_VALUE_TYPE_LIST(DEFINE_TAG)
+#undef DEFINE_TAG
+        kAsmUnknown = 0,
+    kAsmValueTypeTag = 1u
+  };
+
+ private:
+  friend class AsmType;
+
+  static AsmValueType* AsValueType(AsmType* type) {
+    if ((reinterpret_cast<uintptr_t>(type) & kAsmValueTypeTag) ==
+        kAsmValueTypeTag) {
+      return reinterpret_cast<AsmValueType*>(type);
+    }
+    return nullptr;
+  }
+
+  bitset_t Bitset() const {
+    DCHECK((reinterpret_cast<uintptr_t>(this) & kAsmValueTypeTag) ==
+           kAsmValueTypeTag);
+    return static_cast<bitset_t>(reinterpret_cast<uintptr_t>(this) &
+                                 ~kAsmValueTypeTag);
+  }
+
+  static AsmType* New(bitset_t bits) {
+    DCHECK_EQ((bits & kAsmValueTypeTag), 0);
+    return reinterpret_cast<AsmType*>(
+        static_cast<uintptr_t>(bits | kAsmValueTypeTag));
+  }
+
+  // AsmValueTypes can't be created except through AsmValueType::New.
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AsmValueType);
+};
+
+class AsmCallableType : public ZoneObject {
+ public:
+  virtual std::string Name() = 0;
+  virtual AsmType* ValidateCall(AsmType* function_type) = 0;
+
+#define DECLARE_CAST(CamelName) \
+  virtual Asm##CamelName* As##CamelName() { return nullptr; }
+  FOR_EACH_ASM_CALLABLE_TYPE_LIST(DECLARE_CAST)
+#undef DECLARE_CAST
+
+ protected:
+  AsmCallableType() = default;
+  virtual ~AsmCallableType() = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AsmCallableType);
+};
+
+class AsmFunctionType : public AsmCallableType {
+ public:
+  AsmFunctionType* AsFunctionType() final { return this; }
+
+  void AddArgument(AsmType* type) { args_.push_back(type); }
+  const ZoneVector<AsmType*> Arguments() const { return args_; }
+  AsmType* ReturnType() const { return return_type_; }
+
+  virtual bool IsMinMaxType() const { return false; }
+  virtual bool IsFroundType() const { return false; }
+
+ protected:
+  AsmFunctionType(Zone* zone, AsmType* return_type)
+      : return_type_(return_type), args_(zone) {}
+
+ private:
+  friend AsmType;
+
+  std::string Name() override;
+  AsmType* ValidateCall(AsmType* function_type) override;
+
+  AsmType* return_type_;
+  ZoneVector<AsmType*> args_;
+
+  DISALLOW_COPY_AND_ASSIGN(AsmFunctionType);
+};
+
+class AsmOverloadedFunctionType final : public AsmCallableType {
+ public:
+  AsmOverloadedFunctionType* AsOverloadedFunctionType() override {
+    return this;
+  }
+
+  void AddOverload(AsmType* overload);
+
+ private:
+  friend AsmType;
+
+  explicit AsmOverloadedFunctionType(Zone* zone) : overloads_(zone) {}
+
+  std::string Name() override;
+  AsmType* ValidateCall(AsmType* function_type) override;
+
+  ZoneVector<AsmType*> overloads_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(AsmOverloadedFunctionType);
+};
+
+class AsmType {
+ public:
+#define DEFINE_CONSTRUCTOR(CamelName, string_name, number, parent_types) \
+  static AsmType* CamelName() {                                          \
+    return AsmValueType::New(AsmValueType::kAsm##CamelName);             \
+  }
+  FOR_EACH_ASM_VALUE_TYPE_LIST(DEFINE_CONSTRUCTOR)
+#undef DEFINE_CONSTRUCTOR
+
+#define DEFINE_CAST(CamelCase)                                        \
+  Asm##CamelCase* As##CamelCase() {                                   \
+    if (AsValueType() != nullptr) {                                   \
+      return nullptr;                                                 \
+    }                                                                 \
+    return reinterpret_cast<AsmCallableType*>(this)->As##CamelCase(); \
+  }
+  FOR_EACH_ASM_CALLABLE_TYPE_LIST(DEFINE_CAST)
+#undef DEFINE_CAST
+  AsmValueType* AsValueType() { return AsmValueType::AsValueType(this); }
+  AsmCallableType* AsCallableType();
+
+  // A function returning ret. Callers still need to invoke AddArgument with the
+  // returned type to fully create this type.
+  static AsmType* Function(Zone* zone, AsmType* ret) {
+    AsmFunctionType* f = new (zone) AsmFunctionType(zone, ret);
+    return reinterpret_cast<AsmType*>(f);
+  }
+
+  // Overloaded function types. Not creatable by asm source, but useful to
+  // represent the overloaded stdlib functions.
+  static AsmType* OverloadedFunction(Zone* zone) {
+    auto* f = new (zone) AsmOverloadedFunctionType(zone);
+    return reinterpret_cast<AsmType*>(f);
+  }
+
+  // The type for fround(src).
+  static AsmType* FroundType(Zone* zone, AsmType* src);
+
+  // The (variadic) type for min and max.
+  static AsmType* MinMaxType(Zone* zone, AsmType* type);
+
+  std::string Name();
+  // IsExactly returns true if this is the exact same type as that. For
+  // non-value types (e.g., callables), this returns this == that.
+  bool IsExactly(AsmType* that);
+  // IsA is used to query whether this is an instance of that (i.e., if this is
+  // a type derived from that.) For non-value types (e.g., callables), this
+  // returns this == that.
+  bool IsA(AsmType* that);
+
+  // Types allowed in return statements. void is the type for returns without
+  // an expression.
+  bool IsReturnType() {
+    return this == AsmType::Void() || this == AsmType::Double() ||
+           this == AsmType::Signed() || this == AsmType::Float();
+  }
+
+  // Types allowed to be parameters in asm functions.
+  bool IsParameterType() {
+    return this == AsmType::Double() || this == AsmType::Int() ||
+           this == AsmType::Float();
+  }
+
+  // Types allowed to be compared using the comparison operators.
+  bool IsComparableType() {
+    return this == AsmType::Double() || this == AsmType::Signed() ||
+           this == AsmType::Unsigned() || this == AsmType::Float();
+  }
+
+  // The following methods are meant to be used for inspecting the traits of
+  // element types for the heap view types.
+  enum : int32_t { kNotHeapType = -1 };
+
+  // Returns the element size if this is a heap type. Otherwise returns
+  // kNotHeapType.
+  int32_t ElementSizeInBytes();
+  // Returns the load type if this is a heap type. AsmType::None is returned if
+  // this is not a heap type.
+  AsmType* LoadType();
+  // Returns the store type if this is a heap type. AsmType::None is returned if
+  // this is not a heap type.
+  AsmType* StoreType();
+};
+
+}  // namespace wasm
+}  // namespace internal
+}  // namespace v8
+
+#endif  // SRC_WASM_ASM_TYPES_H_

test/unittests/BUILD.gn

@@ -106,6 +106,7 @@ executable("unittests") {
     "run-all-unittests.cc",
     "test-utils.cc",
     "test-utils.h",
+    "wasm/asm-types-unittest.cc",
     "wasm/ast-decoder-unittest.cc",
     "wasm/control-transfer-unittest.cc",
     "wasm/decoder-unittest.cc",

test/unittests/unittests.gyp

@@ -122,6 +122,7 @@
         'run-all-unittests.cc',
         'test-utils.h',
         'test-utils.cc',
+        'wasm/asm-types-unittest.cc',
         'wasm/ast-decoder-unittest.cc',
         'wasm/control-transfer-unittest.cc',
         'wasm/decoder-unittest.cc',