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

src/asmjs/asm-typer.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-typer.h"
 
 #include <limits>
 #include <string>
 
 #include "src/v8.h"
@@ skipping 793 matching lines @@
   CHECK(value != nullptr);
   ZoneList<Expression*>* pointers = value->values();
 
   // The function table size must be n = 2 ** m, for m >= 0;
   // TODO(jpp): should this be capped?
   if (!base::bits::IsPowerOfTwo32(pointers->length())) {
     FAIL(assign, "Invalid length for function pointer table.");
   }
 
   AsmType* table_element_type = nullptr;
-  AsmCallableType* callable_type = nullptr;
   for (auto* initializer : *pointers) {
     auto* var_proxy = initializer->AsVariableProxy();
     if (var_proxy == nullptr) {
       FAIL(initializer,
            "Function pointer table initializer must be a function name.");
     }
 
     auto* var_info = Lookup(var_proxy->var());
     if (var_info == nullptr) {
       FAIL(var_proxy,
            "Undefined identifier in function pointer table initializer.");
     }
 
     if (var_info->standard_member() != kNone) {
       FAIL(initializer,
            "Function pointer table must not be a member of the standard "
            "library.");
     }
 
-    auto* initializer_callable = var_info->type()->AsFunctionType();
-    if (initializer_callable == nullptr) {
+    auto* initializer_type = var_info->type();
+    if (initializer_type->AsFunctionType() == nullptr) {
       FAIL(initializer,
            "Function pointer table initializer must be an asm.js function.");
     }
 
     DCHECK(var_info->type()->AsFFIType() == nullptr);
     DCHECK(var_info->type()->AsFunctionTableType() == nullptr);
 
-    if (callable_type == nullptr) {
-      table_element_type = var_info->type();
-      callable_type = initializer_callable;
-    } else if (callable_type->ValidateCall(initializer_callable->ReturnType(),
-                                           initializer_callable->Arguments()) ==
-               AsmType::None()) {
+    if (table_element_type == nullptr) {
+      table_element_type = initializer_type;
+    } else if (!initializer_type->IsA(table_element_type)) {
       FAIL(initializer, "Type mismatch in function pointer table initializer.");
     }
   }
 
   auto* target_info = Lookup(target_variable);
   if (target_info == nullptr) {
     // Function pointer tables are the last entities to be validates, so this is
     // unlikely to happen: only unreferenced function tables will not already
     // have an entry in the global scope.
     target_info = new (zone_) VariableInfo(AsmType::FunctionTableType(
@@ skipping 16 matching lines @@
   }
 
   if (!target_info->missing_definition()) {
     FAIL(assign, "Identifier redefined (function table name).");
   }
 
   if (target_info_table->length() != pointers->length()) {
     FAIL(assign, "Function table size mismatch.");
   }
 
-  auto* function_type = callable_type->AsFunctionType();
-  if (target_info_table->ValidateCall(function_type->ReturnType(),
-                                      function_type->Arguments()) ==
-      AsmType::None()) {
+  DCHECK(target_info_table->signature()->AsFunctionType());
+  if (!table_element_type->IsA(target_info_table->signature())) {
     FAIL(assign, "Function table initializer does not match previous type.");
   }
 
   target_info->MarkDefined();
   DCHECK(target_info->type() != AsmType::None());
   SetTypeOf(value, target_info->type());
 
   return target_info->type();
 }
 
@@ skipping 144 matching lines @@
 
   auto* fun_type = AsmType::Function(zone_, return_type_);
   auto* fun_type_as_function = fun_type->AsFunctionType();
   for (auto* param_type : parameter_types) {
     fun_type_as_function->AddArgument(param_type);
   }
 
   auto* fun_var = fun_decl_proxy->var();
   auto* fun_info = new (zone_) VariableInfo(fun_type);
   fun_info->set_mutability(VariableInfo::kImmutableGlobal);
-  auto* old_fun_type = Lookup(fun_var);
-  if (old_fun_type == nullptr) {
+  auto* old_fun_info = Lookup(fun_var);
+  if (old_fun_info == nullptr) {
     if (!ValidAsmIdentifier(fun_var->name())) {
       FAIL(fun_decl_proxy, "Invalid asm.js identifier in function name.");
     }
     if (!AddGlobal(fun_var, fun_info)) {
       DCHECK(false);
       FAIL(fun_decl, "Redeclared global identifier.");
     }
 
     SetTypeOf(fun, fun_type);
     return fun_type;
   }
 
   // Not necessarily an error -- fun_decl might have been used before being
   // defined. If that's the case, then the type in the global environment must
   // be the same as the type inferred by the parameter/return type annotations.
-  auto* old_fun_callable = old_fun_type->type()->AsCallableType();
-  if (old_fun_callable == nullptr) {
+  auto* old_fun_type = old_fun_info->type();
+  if (old_fun_type->AsFunctionType() == nullptr) {
     FAIL(fun_decl, "Identifier redefined as function.");
   }
 
-  if (!old_fun_type->missing_definition()) {
+  if (!old_fun_info->missing_definition()) {
     FAIL(fun_decl, "Identifier redefined (function name).");
   }
 
-  if (old_fun_callable->ValidateCall(fun_type_as_function->ReturnType(),
-                                     fun_type_as_function->Arguments()) ==
-      AsmType::None()) {
+  if (!fun_type->IsA(old_fun_type)) {
     FAIL(fun_decl, "Signature mismatch when defining function.");
   }
 
-  old_fun_type->MarkDefined();
+  old_fun_info->MarkDefined();
   SetTypeOf(fun, fun_type);
 
   return fun_type;
 }
 
 // 6.5 ValidateStatement
 AsmType* AsmTyper::ValidateStatement(Statement* statement) {
   switch (statement->node_type()) {
     default:
       FAIL(statement, "Statement type invalid for asm.js.");
@@ skipping 1533 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8