V8. ASM-2-WASM. Another asm-types.h revision.

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() {
+  if (AsValueType() != nullptr) {
+    return nullptr;
+  }
+
   DCHECK(this->AsFunctionType() != nullptr ||
-         this->AsOverloadedFunctionType() != 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;
       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()) {
@@ skipping 52 matching lines @@
     case AsmValueType::kAsmFloat32Array:
       return AsmType::FloatishDoubleQ();
     case AsmValueType::kAsmFloat64Array:
       return AsmType::FloatQDoubleQ();
     default:
       return AsmType::None();
   }
 }
 
 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 {
  public:
   bool IsFroundType() const override { return true; }
 
  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:
   bool IsMinMaxType() const override { return true; }
 
  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 {
     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);
+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* function_type) {
+  auto* callable = function_type->AsFunctionType();
+  if (callable == nullptr) {
+    return nullptr;
+  }
+
+  for (int ii = 0; ii < callable->Arguments().size(); ++ii) {
+    if (!callable->Arguments()[ii]->IsA(AsmType::Extern())) {
+      return AsmType::None();
+    }
+  }
+
+  return callable->ReturnType();
+}
+
 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();
   }
 
@@ skipping 38 matching lines @@
   }
 
   return AsmType::None();
 }
 
 void AsmOverloadedFunctionType::AddOverload(AsmType* overload) {
   DCHECK(overload->AsFunctionType() != nullptr);
   overloads_.push_back(overload);
 }
 
+std::string AsmFunctionTableType::Name() {
+  std::string base_name =
+      signature_ == nullptr ? "[unbound]" : signature_->Name();
+  return base_name + "[" + std::to_string(length_) + "]";
+}
+
+void AsmFunctionTableType::set_signature(AsmType* function_type) {
+  CHECK(function_type->AsFunctionType() != nullptr);
+  signature_ = function_type;
+}
+
+AsmType* AsmFunctionTableType::ValidateCall(AsmType* function_type) {
+  if (signature_ == nullptr) {
+    set_signature(function_type);
+  }
+  return signature_->AsCallableType()->ValidateCall(function_type);
+}
+
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8