V8. ASM-2-WASM. Fixes technical debt in asm-types.

src/asmjs/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/asmjs/asm-types.h"
+
+#include <cinttypes>
+
 #include "src/v8.h"
 
-#include "src/asmjs/asm-types.h"
-
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 AsmCallableType* AsmType::AsCallableType() {
   if (AsValueType() != nullptr) {
     return nullptr;
   }
 
-  DCHECK(this->AsFunctionType() != nullptr ||
-         this->AsOverloadedFunctionType() != nullptr ||
-         this->AsFFIType() != nullptr ||
-         this->AsFunctionTableType() != 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;
@@ skipping 19 matching lines @@
   }
 
   // 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;
+  if (auto* avt = this->AsValueType()) {
+    if (auto* tavt = that->AsValueType()) {
+      return (avt->Bitset() & tavt->Bitset()) == tavt->Bitset();
     }
-    return (avt->Bitset() & tavt->Bitset()) == tavt->Bitset();
+    return false;
   }
 
-  // TODO(jpp): is it useful to allow non-value types to be tested with IsA?
+  if (auto* as_callable = this->AsCallableType()) {
+    return as_callable->IsA(that);
+  }
+
+  UNREACHABLE();
   return that == this;
 }
 
 int32_t AsmType::ElementSizeInBytes() {
   auto* value = AsValueType();
   if (value == nullptr) {
     return AsmType::kNotHeapType;
   }
   switch (value->Bitset()) {
     case AsmValueType::kAsmInt8Array:
@@ skipping 50 matching lines @@
       return AsmType::Intish();
     case AsmValueType::kAsmFloat32Array:
       return AsmType::FloatishDoubleQ();
     case AsmValueType::kAsmFloat64Array:
       return AsmType::FloatQDoubleQ();
     default:
       return AsmType::None();
   }
 }
 
+bool AsmCallableType::IsA(AsmType* other) {
+  return other->AsCallableType() == this;
+}
+
 std::string AsmFunctionType::Name() {
-  if (IsFroundType()) {
-    return "fround";
-  }
-
   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 {
+class AsmFroundType final : public AsmCallableType {
  public:
-  bool IsFroundType() const override { return true; }
-
- private:
   friend AsmType;
 
-  explicit AsmFroundType(Zone* zone)
-      : AsmFunctionType(zone, AsmType::Float()) {}
+  AsmFroundType() : AsmCallableType() {}
 
-  AsmType* ValidateCall(AsmType* return_type,
-                        const ZoneVector<AsmType*>& args) override;
   bool CanBeInvokedWith(AsmType* return_type,
                         const ZoneVector<AsmType*>& args) override;
+
+  std::string Name() override { return "fround"; }
 };
 }  // namespace
 
 AsmType* AsmType::FroundType(Zone* zone) {
-  auto* Fround = new (zone) AsmFroundType(zone);
+  auto* Fround = new (zone) AsmFroundType();
   return reinterpret_cast<AsmType*>(Fround);
 }
 
-// TODO(jpp): Remove this method.
-AsmType* AsmFroundType::ValidateCall(AsmType* return_type,
-                                     const ZoneVector<AsmType*>& args) {
-  if (args.size() != 1) {
-    return AsmType::None();
-  }
-
-  auto* arg = args[0];
-  if (!arg->IsA(AsmType::Floatish()) && !arg->IsA(AsmType::DoubleQ()) &&
-      !arg->IsA(AsmType::Signed()) && !arg->IsA(AsmType::Unsigned())) {
-    return AsmType::None();
-  }
-
-  return AsmType::Float();
-}
-
 bool AsmFroundType::CanBeInvokedWith(AsmType* return_type,
                                      const ZoneVector<AsmType*>& args) {
   if (args.size() != 1) {
     return false;
   }
 
   auto* arg = args[0];
   if (!arg->IsA(AsmType::Floatish()) && !arg->IsA(AsmType::DoubleQ()) &&
       !arg->IsA(AsmType::Signed()) && !arg->IsA(AsmType::Unsigned())) {
     return false;
   }
 
   return true;
 }
 
 namespace {
-class AsmMinMaxType final : public AsmFunctionType {
- public:
-  bool IsMinMaxType() const override { return true; }
-
+class AsmMinMaxType final : public AsmCallableType {
  private:
   friend AsmType;
 
-  AsmMinMaxType(Zone* zone, AsmType* dest, AsmType* src)
-      : AsmFunctionType(zone, dest) {
-    AddArgument(src);
-    AddArgument(src);
-  }
-
-  AsmType* ValidateCall(AsmType* return_type,
-                        const ZoneVector<AsmType*>& args) override {
-    if (!ReturnType()->IsExactly(return_type)) {
-      return AsmType::None();
-    }
-
-    if (args.size() < 2) {
-      return AsmType::None();
-    }
-
-    for (size_t ii = 0; ii < Arguments().size(); ++ii) {
-      if (!Arguments()[0]->IsExactly(args[ii])) {
-        return AsmType::None();
-      }
-    }
-
-    return ReturnType();
-  }
+  AsmMinMaxType(AsmType* dest, AsmType* src)
+      : AsmCallableType(), return_type_(dest), arg_(src) {}
 
   bool CanBeInvokedWith(AsmType* return_type,
                         const ZoneVector<AsmType*>& args) override {
-    if (!ReturnType()->IsExactly(return_type)) {
+    if (!return_type_->IsExactly(return_type)) {
       return false;
     }
 
     if (args.size() < 2) {
       return false;
     }
 
-    auto* arg_type = Arguments()[0];
-    for (size_t ii = 0; ii < Arguments().size(); ++ii) {
-      if (!args[ii]->IsA(arg_type)) {
+    for (size_t ii = 0; ii < args.size(); ++ii) {
+      if (!args[ii]->IsA(arg_)) {
         return false;
       }
     }
 
     return true;
   }
+
+  std::string Name() override {
+    return "(" + arg_->Name() + ", " + arg_->Name() + "...) -> " +
+           return_type_->Name();
+  }
+
+  AsmType* return_type_;
+  AsmType* arg_;
 };
 }  // namespace
 
 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);
+  auto* MinMax = new (zone) AsmMinMaxType(dest, src);
   return reinterpret_cast<AsmType*>(MinMax);
 }
 
-AsmType* AsmFFIType::ValidateCall(AsmType* return_type,
-                                  const ZoneVector<AsmType*>& args) {
-  for (size_t ii = 0; ii < args.size(); ++ii) {
-    if (!args[ii]->IsA(AsmType::Extern())) {
-      return AsmType::None();
-    }
-  }
-
-  return return_type;
-}
-
 bool AsmFFIType::CanBeInvokedWith(AsmType* return_type,
                                   const ZoneVector<AsmType*>& args) {
   if (return_type->IsExactly(AsmType::Float())) {
     return false;
   }
 
   for (size_t ii = 0; ii < args.size(); ++ii) {
     if (!args[ii]->IsA(AsmType::Extern())) {
       return false;
     }
   }
 
   return true;
 }
 
-AsmType* AsmFunctionType::ValidateCall(AsmType* return_type,
-                                       const ZoneVector<AsmType*>& args) {
-  if (!return_type_->IsExactly(return_type)) {
-    return AsmType::None();
+bool AsmFunctionType::IsA(AsmType* other) {
+  auto* that = other->AsFunctionType();
+  if (that == nullptr) {
+    return false;
+  }
+  if (!return_type_->IsExactly(that->return_type_)) {
+    return false;
   }
 
-  if (args_.size() != args.size()) {
-    return AsmType::None();
+  if (args_.size() != that->args_.size()) {
+    return false;
   }
 
   for (size_t ii = 0; ii < args_.size(); ++ii) {
-    if (!args_[ii]->IsExactly(args[ii])) {
-      return AsmType::None();
+    if (!args_[ii]->IsExactly(that->args_[ii])) {
+      return false;
     }
   }
 
-  return return_type_;
+  return true;
 }
 
 bool AsmFunctionType::CanBeInvokedWith(AsmType* return_type,
                                        const ZoneVector<AsmType*>& args) {
   if (!return_type_->IsExactly(return_type)) {
     return false;
   }
 
   if (args_.size() != args.size()) {
     return false;
@@ skipping 14 matching lines @@
   for (size_t ii = 0; ii < overloads_.size(); ++ii) {
     if (ii != 0) {
       ret += " /\\ ";
     }
     ret += overloads_[ii]->Name();
   }
 
   return ret;
 }
 
-AsmType* AsmOverloadedFunctionType::ValidateCall(
-    AsmType* return_type, const ZoneVector<AsmType*>& args) {
-  for (size_t ii = 0; ii < overloads_.size(); ++ii) {
-    auto* validated_type =
-        overloads_[ii]->AsCallableType()->ValidateCall(return_type, args);
-    if (validated_type != AsmType::None()) {
-      return validated_type;
-    }
-  }
-
-  return AsmType::None();
-}
-
 bool AsmOverloadedFunctionType::CanBeInvokedWith(
     AsmType* return_type, const ZoneVector<AsmType*>& args) {
   for (size_t ii = 0; ii < overloads_.size(); ++ii) {
     if (overloads_[ii]->AsCallableType()->CanBeInvokedWith(return_type, args)) {
       return true;
     }
   }
 
   return false;
 }
 
 void AsmOverloadedFunctionType::AddOverload(AsmType* overload) {
-  DCHECK(overload->AsFunctionType() != nullptr);
+  DCHECK(overload->AsCallableType() != nullptr);
   overloads_.push_back(overload);
 }
 
 AsmFunctionTableType::AsmFunctionTableType(size_t length, AsmType* signature)
     : length_(length), signature_(signature) {
   DCHECK(signature_ != nullptr);
   DCHECK(signature_->AsFunctionType() != nullptr);
 }
 
+namespace {
+// ToString is used for reporting function tables' names. It converts its
+// argument to uint32_t because asm.js integers are 32-bits, thus effectively
+// limiting the max function table's length.
+std::string ToString(size_t s) {
+  auto u32 = static_cast<uint32_t>(s);
+  // 16 bytes is more than enough to represent a 32-bit integer as a base 10
+  // string.
+  char digits[16];
+  int length = base::OS::SNPrintF(digits, arraysize(digits), "%" PRIu32, u32);
+  DCHECK_NE(length, -1);
+  return std::string(digits, length);
+}
+}  // namespace
+
 std::string AsmFunctionTableType::Name() {
-  return signature_->Name() + "[" + std::to_string(length_) + "]";
-}
-
-AsmType* AsmFunctionTableType::ValidateCall(AsmType* return_type,
-                                            const ZoneVector<AsmType*>& args) {
-  return signature_->AsCallableType()->ValidateCall(return_type, args);
+  return "(" + signature_->Name() + ")[" + ToString(length_) + "]";
 }
 
 bool AsmFunctionTableType::CanBeInvokedWith(AsmType* return_type,
                                             const ZoneVector<AsmType*>& args) {
   return signature_->AsCallableType()->CanBeInvokedWith(return_type, args);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8