Forbid non-locals/keyed-property calls to allow interleaved compile.

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 82 matching lines @@
     VariableName& operator=(const VariableName&) = default;
 
     const char* name_;
     const VariableMode mode_;
   };
 
   AsmTyperHarnessBuilder* WithLocal(VariableName var_name, AsmType* type) {
     CHECK(validation_type_ == ValidateStatement ||
           validation_type_ == ValidateExpression);
     auto* var = DeclareVariable(var_name);
+    if (var->IsUnallocated()) {
+      var->AllocateTo(VariableLocation::LOCAL, -1);
+    }
     auto* var_info = new (zone_) AsmTyper::VariableInfo(type);
     var_info->set_mutability(AsmTyper::VariableInfo::kLocal);
     CHECK(typer_->AddLocal(var, var_info));
     return this;
   }
 
   AsmTyperHarnessBuilder* WithGlobal(VariableName var_name, AsmType* type) {
     auto* var = DeclareVariable(var_name);
-    auto* var_info = new (zone_) AsmTyper::VariableInfo(type);
-    var_info->set_mutability(AsmTyper::VariableInfo::kMutableGlobal);
-    CHECK(typer_->AddGlobal(var, var_info));
+    if (var->IsUnallocated()) {
+      var->AllocateTo(VariableLocation::MODULE, -1);
+    }
+    if (type != nullptr) {
+      auto* var_info = new (zone_) AsmTyper::VariableInfo(type);
+      var_info->set_mutability(AsmTyper::VariableInfo::kMutableGlobal);
+      CHECK(typer_->AddGlobal(var, var_info));
+    }
     return this;
   }
 
   AsmTyperHarnessBuilder* WithGlobal(
       VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
     return WithGlobal(var_name, type_creator(zone_));
   }
 
   AsmTyperHarnessBuilder* WithUndefinedGlobal(
       VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
     auto* type = type_creator(zone_);
     CHECK(type->AsFunctionType() != nullptr ||
           type->AsFunctionTableType() != nullptr);
     WithGlobal(var_name, type);
     auto* var_info = typer_->Lookup(DeclareVariable(var_name));
     CHECK(var_info);
     MessageLocation location;
     var_info->SetFirstForwardUse(location);
     return this;
   }
 
   AsmTyperHarnessBuilder* WithImport(VariableName var_name,
                                      AsmTyper::StandardMember standard_member) {
     auto* var = DeclareVariable(var_name);
+    if (var->IsUnallocated()) {
+      var->AllocateTo(VariableLocation::LOCAL, -1);
+    }
     AsmTyper::VariableInfo* var_info = nullptr;
     auto* stdlib_map = &typer_->stdlib_math_types_;
     switch (standard_member) {
       case AsmTyper::kHeap:
       case AsmTyper::kStdlib:
       case AsmTyper::kModule:
       case AsmTyper::kNone:
         CHECK(false);
       case AsmTyper::kFFI:
         stdlib_map = nullptr;
@@ skipping 64 matching lines @@
 
     if (validation_type_ == ValidateStatement) {
       CHECK(typer_->return_type_ != AsmType::None());
       if (ValidateAllStatements(fun_decl_)) {
         return true;
       }
     } else if (typer_->Validate()) {
       return true;
     }
 
-    std::cerr << "Asm validation failed: " << typer_->error_message() << "\n";
+    std::unique_ptr<char[]> msg = i::MessageHandler::GetLocalizedMessage(
+        isolate_, typer_->error_message());
+    std::cerr << "Asm validation failed: " << msg.get() << "\n";
     return false;
   }
 
   bool SucceedsWithExactType(AsmType* type) {
     CHECK(validation_type_ == ValidateExpression);
     auto* validated_as = ValidateExpressionStatment(fun_decl_);
     if (validated_as == AsmType::None()) {
-      std::cerr << "Validation failure: " << typer_->error_message() << "\n";
+      std::unique_ptr<char[]> msg = i::MessageHandler::GetLocalizedMessage(
+          isolate_, typer_->error_message());
+      std::cerr << "Validation failure: " << msg.get() << "\n";
       return false;
     } else if (validated_as != type) {
       std::cerr << "Validation succeeded with wrong type "
                 << validated_as->Name() << " (vs. " << type->Name() << ").\n";
       return false;
     }
 
     return true;
   }
 
@@ skipping 427 matching lines @@
       {"return f();", "Unrecognized expression in asm.js module export"},
       {"return d2s_tbl;", "cannot export function tables"},
       {"return min;", "cannot export standard library functions"},
       {"return ffi;", "cannot export foreign functions"},
       {"return I;", "is not an asm.js function"},
       {"return {'a': d2s_tbl}", "cannot export function tables"},
       {"return {'a': min}", "cannot export standard library functions"},
       {"return {'a': ffi}", "cannot export foreign functions"},
       {"return {'a': f()}", "must be an asm.js function name"},
       {"return {'a': f}", "Undefined identifier in asm.js module export"},
-      {"function v() { a(); } return {b: d2s}", "Missing definition for forw"},
+      {"function v() { a(); } return {b: d2s}",
+       "Invalid call of existing global function"},
       {"function v() {} return {b: v, 'a': d2s_tbl}",
        "cannot export function tables"},
       {"function v() {} return {b: v, 'a': min}",
        "cannot export standard library"},
       {"function v() {} return {b: v, 'a': ffi}",
        "cannot export foreign functions"},
       {"function v() {} return {b: v, 'a': f()}",
        "must be an asm.js function name"},
       {"function v() {} return {b: v, 'a': f}",
        "Undefined identifier in asm.js module"},
@@ skipping 216 matching lines @@
        "Case label must be a 32-bit signed"},
   };
 
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     const auto* test = kTests + ii;
     if (!ValidationOf(Statement(test->statement))
              ->WithReturnType(iw::AsmType::Signed())
              ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
              ->WithLocal(DynamicGlobal("flocal"), iw::AsmType::Float())
              ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
+             ->WithGlobal(DynamicGlobal("d"), nullptr)
              ->FailsWithMessage(test->error_message)) {
       std::cerr << "Test:\n" << test->statement;
       CHECK(false);
     }
   }
 }
 
 TEST(ErrorsInExpression) {
   auto d2d = [](Zone* zone) -> iw::AsmType* {
     auto* ret = iw::AsmType::Function(zone, iw::AsmType::Double());
@@ skipping 110 matching lines @@
              ->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())
              ->WithGlobal(DynamicGlobal("HEAP8"), iw::AsmType::Int8Array())
+             ->WithGlobal(DynamicGlobal("a"), nullptr)
              ->FailsWithMessage(test->error_message)) {
       std::cerr << "Test:\n" << test->expression;
       CHECK(false);
     }
   }
 }
 
 TEST(ValidateNumericLiteral) {
   const struct {
     const char* expression;
@@ skipping 307 matching lines @@
              ->WithLocal(DynamicGlobal("dlocal"), iw::AsmType::Double())
              ->WithLocal(DynamicGlobal("flocal"), iw::AsmType::Float())
              ->WithGlobal(DynamicGlobal("I8"), iw::AsmType::Int8Array())
              ->WithGlobal(DynamicGlobal("U8"), iw::AsmType::Uint8Array())
              ->WithGlobal(DynamicGlobal("I16"), iw::AsmType::Int16Array())
              ->WithGlobal(DynamicGlobal("U16"), iw::AsmType::Uint16Array())
              ->WithGlobal(DynamicGlobal("I32"), iw::AsmType::Int32Array())
              ->WithGlobal(DynamicGlobal("U32"), iw::AsmType::Uint32Array())
              ->WithGlobal(DynamicGlobal("F32"), iw::AsmType::Float32Array())
              ->WithGlobal(DynamicGlobal("F64"), iw::AsmType::Float64Array())
+             ->WithGlobal(DynamicGlobal("make_float"), nullptr)
+             ->WithGlobal(DynamicGlobal("make_double"), nullptr)
              ->SucceedsWithExactType(test->load_type)) {
       std::cerr << "Test:\n" << test->expression;
       CHECK(false);
     }
   }
 }
 
 TEST(ValidateUnaryExpression) {
   auto v2d = [](Zone* zone) -> iw::AsmType* {
     auto* ret = iw::AsmType::Function(zone, iw::AsmType::Double());
@@ skipping 35 matching lines @@
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     const auto* test = kTests + ii;
     if (!ValidationOf(Expression(test->expression))
              ->WithLocal(DynamicGlobal("fq"), iw::AsmType::FloatQ())
              ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
              ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
              ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
              ->WithLocal(DynamicGlobal("ulocal"), iw::AsmType::Unsigned())
              ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
              ->WithGlobal(DynamicGlobal("dglobal"), iw::AsmType::Double())
+             ->WithGlobal(DynamicGlobal("make_double"), nullptr)
              ->WithGlobal(DynamicGlobal("dbl"), v2d)
              ->SucceedsWithExactType(test->load_type)) {
       std::cerr << "Test:\n" << test->expression;
       CHECK(false);
     }
   }
 }
 
 TEST(ValidateMultiplicativeExpression) {
   const struct {
@@ skipping 229 matching lines @@
       {"make_signed()|0", iw::AsmType::Signed()},
       {"signed()|0", iw::AsmType::Signed()},
   };
 
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     const auto* test = kTests + ii;
     if (!ValidationOf(Expression(test->expression))
              ->WithLocal(DynamicGlobal("iish1"), iw::AsmType::Intish())
              ->WithLocal(DynamicGlobal("iish0"), iw::AsmType::Intish())
              ->WithGlobal(DynamicGlobal("signed"), v2s)
+             ->WithGlobal(DynamicGlobal("make_signed"), nullptr)
              ->SucceedsWithExactType(test->load_type)) {
       std::cerr << "Test:\n" << test->expression;
       CHECK(false);
     }
   }
 }
 
 TEST(ValidateConditionalExpression) {
   const struct {
     const char* expression;
@@ skipping 27 matching lines @@
     return ret;
   };
 
   // ifd2_ is a helper function that returns a lambda for creating a function
   // type that accepts an int, a float, and a double. ret_type_factory is a
   // pointer to an AsmType*() function, and (*ret_type_factory)() returns the
   // desired return type. For example,
   //
   // ifd2_(&iw::AsmType::Float)
   //
-  // returns an AsmType representing an asm.j function with the following
+  // returns an AsmType representing an asm.js function with the following
   // signature:
   //
   // float(int, float, double)
   auto ifd2_ = [](iw::AsmType* (
       *ret_type_factory)()) -> std::function<iw::AsmType*(Zone*)> {
     return [ret_type_factory](Zone* zone) -> iw::AsmType* {
       auto* ret = iw::AsmType::Function(zone, (*ret_type_factory)());
       ret->AsFunctionType()->AddArgument(iw::AsmType::Int());
       ret->AsFunctionType()->AddArgument(iw::AsmType::Float());
       ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
@@ skipping 56 matching lines @@
     const auto* test = kTests + ii;
     if (!ValidationOf(Expression(test->expression))
              ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
              ->WithImport(DynamicGlobal("ffi"), iw::AsmTyper::kFFI)
              ->WithLocal(DynamicGlobal("fish"), iw::AsmType::Floatish())
              ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
              ->WithLocal(DynamicGlobal("s"), iw::AsmType::Signed())
              ->WithLocal(DynamicGlobal("u"), iw::AsmType::Unsigned())
              ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
              ->WithGlobal(DynamicGlobal("v2f"), v2f)
+             ->WithGlobal(DynamicGlobal("ifd2f"), nullptr)
+             ->WithGlobal(DynamicGlobal("ifd2d"), nullptr)
+             ->WithGlobal(DynamicGlobal("ifd2i"), nullptr)
              ->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);
     }
   }
 }
 
@@ skipping 241 matching lines @@
     if (!ValidationOf(Module(kTests[ii]))
              ->FailsWithMessage(
                  "Constant in return must be signed, float, or double.")) {
       std::cerr << "Test:\n" << kTests[ii];
       CHECK(false);
     }
   }
 }
 
 }  // namespace