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

test/cctest/asmjs/test-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 <cstring>
 #include <functional>
 #include <iostream>
 #include <memory>
 
 #include "src/asmjs/asm-typer.h"
@@ skipping 159 matching lines @@
 
   AsmTyperHarnessBuilder* WithReturnType(AsmType* type) {
     CHECK(type->IsReturnType());
     CHECK(typer_->return_type_ == AsmType::None());
     typer_->return_type_ = type;
     return this;
   }
 
   AsmTyperHarnessBuilder* WithStdlib(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
-    auto* var_info = new (zone_) AsmTyper::VariableInfo();
-    var_info->set_mutability(AsmTyper::VariableInfo::kImmutableGlobal);
-    var_info->set_standard_member(AsmTyper::kStdlib);
+    auto* var_info =
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kStdlib);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
 
   AsmTyperHarnessBuilder* WithHeap(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
-    auto* var_info = new (zone_) AsmTyper::VariableInfo();
-    var_info->set_mutability(AsmTyper::VariableInfo::kImmutableGlobal);
-    var_info->set_standard_member(AsmTyper::kHeap);
+    auto* var_info =
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kHeap);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
 
   AsmTyperHarnessBuilder* WithFFI(VariableName var_name) {
     auto* var = DeclareVariable(var_name);
     auto* var_info =
-        new (zone_) AsmTyper::VariableInfo(AsmType::FFIType(zone_));
-    var_info->set_mutability(AsmTyper::VariableInfo::kImmutableGlobal);
-    var_info->set_standard_member(AsmTyper::kFFI);
+        AsmTyper::VariableInfo::ForSpecialSymbol(zone_, AsmTyper::kFFI);
     CHECK(typer_->AddGlobal(var, var_info));
     return this;
   }
 
   bool Succeeds() {
     CHECK(validation_type_ == ValidateModule ||
           validation_type_ == ValidateGlobals ||
           validation_type_ == ValidateFunctionTables ||
           validation_type_ == ValidateExport ||
           validation_type_ == ValidateFunction ||
@@ skipping 691 matching lines @@
     auto* ret = iw::AsmType::FunctionTableType(zone, 2, d2s);
     return ret;
   };
 
   const struct {
     const char* expression;
     const char* error_message;
   } kTests[] = {
       {"noy_a_function();", "Unanotated call to a function must be a call to"},
       {"a = 0;", "Undeclared identifier"},
+      // we can't verify the module's name being referenced here because
+      // expression validation does not invoke ValidateModule, which sets up the
+      // module information in the AsmTyper.
+      {"stdlib", "accessed by ordinary expressions"},
+      {"ffi", "accessed by ordinary expressions"},
+      {"heap", "accessed by ordinary expressions"},
+      {"d2d", "accessed by ordinary expression"},
+      {"fround", "accessed by ordinary expression"},
+      {"d2s_tbl", "accessed by ordinary expression"},
       {"ilocal = +1.0", "Type mismatch in assignment"},
       {"!dlocal", "Invalid type for !"},
       {"2 * dlocal", "Invalid types for intish *"},
       {"dlocal * 2", "Invalid types for intish *"},
       {"1048577 * ilocal", "Invalid operands for *"},
       {"1048577 / ilocal", "Invalid operands for /"},
       {"1048577 % dlocal", "Invalid operands for %"},
       {"1048577 * dlocal", "Invalid operands for *"},
       {"1048577 / dlocal", "Invalid operands for /"},
       {"1048577 % ilocal", "Invalid operands for %"},
@@ skipping 59 matching lines @@
       // *VIOLATION* the following is invalid, but because of desugaring it is
       // accepted.
       // {"HEAP32[0 >> 1] = 0", "Invalid heap access index"},
       {"HEAP8[fround(0.0)] = 0", "Invalid heap access index for byte array"},
       {"HEAP8[iish] = 0", "Invalid heap access index for byte array"},
   };
 
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     const auto* test = kTests + ii;
     if (!ValidationOf(Expression(test->expression))
+             ->WithStdlib(DynamicGlobal("stdlib"))
+             ->WithFFI(DynamicGlobal("ffi"))
+             ->WithHeap(DynamicGlobal("heap"))
              ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
              ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
              ->WithLocal(DynamicGlobal("dlocal"), iw::AsmType::Double())
              ->WithLocal(DynamicGlobal("dlocal2"), iw::AsmType::Double())
              ->WithLocal(DynamicGlobal("not_a_function"), iw::AsmType::Int())
              ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
              ->WithImport(DynamicGlobal("FFI"), iw::AsmTyper::kFFI)
              ->WithGlobal(DynamicGlobal("d2d"), d2d)
              ->WithGlobal(DynamicGlobal("d2s_tbl"), d2s_tbl)
              ->WithGlobal(DynamicGlobal("HEAP32"), iw::AsmType::Int32Array())
@@ skipping 754 matching lines @@
              ->WithGlobal(DynamicGlobal("ifd2f_tbl"), ifd2f_tbl)
              ->WithGlobal(DynamicGlobal("ifd2d_tbl"), ifd2d_tbl)
              ->WithGlobal(DynamicGlobal("ifd2i_tbl"), ifd2i_tbl)
              ->SucceedsWithExactType(test->load_type)) {
       std::cerr << "Test:\n" << test->expression;
       CHECK(false);
     }
   }
 }
 
+TEST(CannotReferenceModuleName) {
+  v8::V8::Initialize();
+
+  const struct {
+    const char* module;
+    const char* error_message;
+  } kTests[] = {
+      {"function asm() {\n"
+       "  'use asm';\n"
+       "  function f() { asm; }\n"
+       "}",
+       "accessed by ordinary expressions"},
+      {"function asm() { 'use asm'; return asm; }", "Module cannot export"},
+  };
+
+  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
+    const auto* test = kTests + ii;
+    if (!ValidationOf(Module(test->module))
+             ->FailsWithMessage(test->error_message)) {
+      std::cerr << "Test:\n" << test->module;
+      CHECK(false);
+    }
+  }
+}
+
 }  // namespace