V8. ASM-2-WASM. Fixes issue 628446.

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 74 matching lines @@
       continue;
     }
 
     return current_statement;
   }
 }
 
 // ----------------------------------------------------------------------------
 // Implementation of AsmTyper::VariableInfo
 
+AsmTyper::VariableInfo* AsmTyper::VariableInfo::ForSpecialSymbol(
+    Zone* zone, StandardMember standard_member) {
+  DCHECK(standard_member == kStdlib || standard_member == kFFI ||
+         standard_member == kHeap || standard_member == kModule);
+  auto* new_var_info = new (zone) VariableInfo(AsmType::None());
+  new_var_info->standard_member_ = standard_member;
+  new_var_info->mutability_ = kImmutableGlobal;
+  return new_var_info;
+}
+
 AsmTyper::VariableInfo* AsmTyper::VariableInfo::Clone(Zone* zone) const {
   CHECK(standard_member_ != kNone);
+  CHECK(!type_->IsA(AsmType::None()));
   auto* new_var_info = new (zone) VariableInfo(type_);
   new_var_info->standard_member_ = standard_member_;
   new_var_info->mutability_ = mutability_;
   return new_var_info;
 }
 
 void AsmTyper::VariableInfo::FirstForwardUseIs(VariableProxy* var) {
   DCHECK(first_forward_use_ == nullptr);
   missing_definition_ = true;
   first_forward_use_ = var;
 }
 
 // ----------------------------------------------------------------------------
 // Implementation of AsmTyper
 
 AsmTyper::AsmTyper(Isolate* isolate, Zone* zone, Script* script,
                    FunctionLiteral* root)
     : isolate_(isolate),
       zone_(zone),
       script_(script),
       root_(root),
       forward_definitions_(zone),
       stdlib_types_(zone),
       stdlib_math_types_(zone),
+      module_info_(VariableInfo::ForSpecialSymbol(zone_, kModule)),
       global_scope_(ZoneHashMap::PointersMatch,
                     ZoneHashMap::kDefaultHashMapCapacity,
                     ZoneAllocationPolicy(zone)),
       local_scope_(ZoneHashMap::PointersMatch,
                    ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
       stack_limit_(isolate->stack_guard()->real_climit()),
       node_types_(zone_),
-      fround_type_(AsmType::FroundType(zone_)) {
+      fround_type_(AsmType::FroundType(zone_)),
+      ffi_type_(AsmType::FFIType(zone_)) {
   InitializeStdlib();
-  module_info_.set_standard_member(kModule);
 }
 
 namespace {
 bool ValidAsmIdentifier(Handle<String> name) {
   static const char* kInvalidAsmNames[] = {"eval", "arguments"};
 
   for (size_t ii = 0; ii < arraysize(kInvalidAsmNames); ++ii) {
     if (strcmp(name->ToCString().get(), kInvalidAsmNames[ii]) == 0) {
       return false;
     }
@@ skipping 169 matching lines @@
 AsmTyper::VariableInfo* AsmTyper::Lookup(Variable* variable) {
   ZoneHashMap* scope = in_function_ ? &local_scope_ : &global_scope_;
   ZoneHashMap::Entry* entry =
       scope->Lookup(variable, ComputePointerHash(variable));
   if (entry == nullptr && in_function_) {
     entry = global_scope_.Lookup(variable, ComputePointerHash(variable));
   }
 
   if (entry == nullptr && !module_name_.is_null() &&
       module_name_->Equals(*variable->name())) {
-    return &module_info_;
+    return module_info_;
   }
 
   return entry ? reinterpret_cast<VariableInfo*>(entry->value) : nullptr;
 }
 
 void AsmTyper::AddForwardReference(VariableProxy* proxy, VariableInfo* info) {
   info->FirstForwardUseIs(proxy);
   forward_definitions_.push_back(info);
 }
 
@@ skipping 130 matching lines @@
   module_name_ = fun->name();
 
   // Allowed parameters: Stdlib, FFI, Mem
   static const uint32_t MaxModuleParameters = 3;
   if (scope->num_parameters() > MaxModuleParameters) {
     FAIL(fun, "asm.js modules may not have more than three parameters.");
   }
 
   struct {
     StandardMember standard_member;
-    AsmType* type;
   } kModuleParamInfo[3] = {
-      {kStdlib, AsmType::None()},
-      {kFFI, AsmType::FFIType(zone_)},
-      {kHeap, AsmType::None()},
+      {kStdlib}, {kFFI}, {kHeap},
   };
 
   for (int ii = 0; ii < scope->num_parameters(); ++ii) {
     Variable* param = scope->parameter(ii);
     DCHECK(param);
 
     if (!ValidAsmIdentifier(param->name())) {
       FAIL(fun, "Invalid asm.js identifier in module parameter.");
     }
 
-    auto* param_info = new (zone_) VariableInfo();
-    param_info->set_mutability(VariableInfo::kImmutableGlobal);
-    param_info->set_standard_member(kModuleParamInfo[ii].standard_member);
-    param_info->set_type(kModuleParamInfo[ii].type);
+    auto* param_info = VariableInfo::ForSpecialSymbol(
+        zone_, kModuleParamInfo[ii].standard_member);
 
     if (!AddGlobal(param, param_info)) {
       FAIL(fun, "Redeclared identifier in module parameter.");
     }
   }
 
   ZoneVector<Assignment*> function_pointer_tables(zone_);
   FlattenedStatements iter(zone_, fun->body());
   auto* use_asm_directive = iter.Next();
   if (use_asm_directive == nullptr || !IsUseAsmDirective(use_asm_directive)) {
@@ skipping 143 matching lines @@
   } else if (value->IsProperty()) {
     target_info = ImportLookup(value->AsProperty());
     if (target_info == nullptr) {
       FAIL(assign, "Invalid import.");
     }
     CHECK(target_info->mutability() == VariableInfo::kImmutableGlobal);
     if (!target_info->IsFFI()) {
       target_info = target_info->Clone(zone_);
     } else {
       // create a new target info that represents a foreign variable.
-      DCHECK(target_info->type()->AsFFIType() != nullptr);
-      target_info = new (zone_) VariableInfo(target_info->type());
+      target_info = new (zone_) VariableInfo(ffi_type_);
       target_info->set_mutability(VariableInfo::kImmutableGlobal);
     }
   } else if (value->IsBinaryOperation()) {
     // This should either be:
     //
     // var <> = ffi.<>|0
     //
     // or
     //
     // var <> = +ffi.<>
@@ skipping 22 matching lines @@
       FAIL(value,
            "Invalid initializer for foreign import - object lookup failed.");
     }
     CHECK(target_info->mutability() == VariableInfo::kImmutableGlobal);
     if (!target_info->IsFFI()) {
       FAIL(value,
            "Invalid initializer for foreign import - object is not the ffi.");
     }
 
     // Create a new target info that represents the foreign import.
-    DCHECK(target_info->type()->AsFFIType() != nullptr);
     target_info = new (zone_) VariableInfo(import_type);
     target_info->set_mutability(VariableInfo::kMutableGlobal);
   } else if (value->IsCallNew()) {
     AsmType* type = nullptr;
     RECURSE(type = NewHeapView(value->AsCallNew()));
     target_info = new (zone_) VariableInfo(type);
     target_info->set_mutability(VariableInfo::kImmutableGlobal);
   }
 
   if (target_info == nullptr) {
@@ skipping 835 matching lines @@
 
   return AsmType::Unsigned();
 }
 
 // 6.8.3 Identifier
 AsmType* AsmTyper::ValidateIdentifier(VariableProxy* proxy) {
   auto* proxy_info = Lookup(proxy->var());
   if (proxy_info == nullptr) {
     FAIL(proxy, "Undeclared identifier.");
   }
-  if (proxy_info->type()->AsCallableType() != nullptr) {
+  auto* type = proxy_info->type();
+  if (type->IsA(AsmType::None()) || type->AsCallableType() != nullptr) {
     FAIL(proxy, "Identifier may not be accessed by ordinary expressions.");
   }
-  DCHECK(!proxy_info->type()->IsA(AsmType::None()));
-  return proxy_info->type();
+  return type;
 }
 
 // 6.8.4 CallExpression
 AsmType* AsmTyper::ValidateCallExpression(Call* call) {
   AsmType* return_type;
   RECURSE(return_type = ValidateFloatCoercion(call));
   if (return_type == nullptr) {
     FAIL(call, "Unanotated call to a function must be a call to fround.");
   }
   return return_type;
@@ skipping 1052 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8