V8. ASM-2-WASM. Migrates asm-wasm-builder to the new asm-typer.

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/v8.h"
 
 #include "src/asmjs/asm-types.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 155 matching lines @@
   bool IsFroundType() const override { return true; }
 
  private:
   friend AsmType;
 
   explicit AsmFroundType(Zone* zone)
       : AsmFunctionType(zone, AsmType::Float()) {}
 
   AsmType* ValidateCall(AsmType* return_type,
                         const ZoneVector<AsmType*>& args) override;
+  bool CanBeInvokedWith(AsmType* return_type,
+                        const ZoneVector<AsmType*>& args) override;
 };
 }  // namespace
 
 AsmType* AsmType::FroundType(Zone* zone) {
   auto* Fround = new (zone) AsmFroundType(zone);
   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; }
 
  private:
   friend AsmType;
 
   AsmMinMaxType(Zone* zone, AsmType* dest, AsmType* src)
       : AsmFunctionType(zone, dest) {
@@ skipping 12 matching lines @@
     }
 
     for (size_t ii = 0; ii < Arguments().size(); ++ii) {
       if (!Arguments()[0]->IsExactly(args[ii])) {
         return AsmType::None();
       }
     }
 
     return ReturnType();
   }
+
+  bool CanBeInvokedWith(AsmType* return_type,
+                        const ZoneVector<AsmType*>& args) override {
+    if (!ReturnType()->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)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
 };
 }  // 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);
   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();
   }
 
   if (args_.size() != args.size()) {
     return AsmType::None();
   }
 
   for (size_t ii = 0; ii < args_.size(); ++ii) {
     if (!args_[ii]->IsExactly(args[ii])) {
       return AsmType::None();
     }
   }
 
   return return_type_;
 }
 
+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;
+  }
+
+  for (size_t ii = 0; ii < args_.size(); ++ii) {
+    if (!args[ii]->IsA(args_[ii])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 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* 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);
   overloads_.push_back(overload);
 }
 
 AsmFunctionTableType::AsmFunctionTableType(size_t length, AsmType* signature)
     : length_(length), signature_(signature) {
   DCHECK(signature_ != nullptr);
   DCHECK(signature_->AsFunctionType() != nullptr);
 }
 
 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);
 }
 
+bool AsmFunctionTableType::CanBeInvokedWith(AsmType* return_type,
+                                            const ZoneVector<AsmType*>& args) {
+  return signature_->AsCallableType()->CanBeInvokedWith(return_type, args);
+}
+
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8