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

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 <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
@@ skipping 2371 matching lines @@
       fun_info->set_mutability(VariableInfo::kImmutableGlobal);
       AddForwardReference(call_var_proxy, fun_info);
       if (!ValidAsmIdentifier(call_var_proxy->name())) {
         FAIL(call_var_proxy,
              "Invalid asm.js identifier in (forward) function name.");
       }
       if (!AddGlobal(call_var_proxy->var(), fun_info)) {
         DCHECK(false);
         FAIL(call, "Redeclared global identifier.");
       }
+      if (call->GetCallType() != Call::OTHER_CALL) {
+        FAIL(call, "Invalid call of existing global function.");
+      }
       SetTypeOf(call_var_proxy, reinterpret_cast<AsmType*>(call_type));
       SetTypeOf(call, return_type);
       return return_type;
     }
 
     auto* callee_type = call_var_info->type()->AsCallableType();
     if (callee_type == nullptr) {
       FAIL(call, "Calling something that's not a function.");
     }
 
@@ skipping 10 matching lines @@
       sig->arg_types_.reserve(args.size());
       for (size_t i = 0; i < args.size(); ++i) {
         sig->arg_types_.emplace_back(args[i]);
       }
     }
 
     if (!callee_type->CanBeInvokedWith(return_type, args)) {
       FAIL(call, "Function invocation does not match function type.");
     }
 
+    if (call->GetCallType() != Call::OTHER_CALL) {
+      FAIL(call, "Invalid forward call of global function.");
+    }
+
     SetTypeOf(call_var_proxy, call_var_info->type());
     SetTypeOf(call, return_type);
     return return_type;
   }
 
   // identifier[expr & n](Expression...)
   if (auto* call_property = call_expr->AsProperty()) {
     auto* index = call_property->key()->AsBinaryOperation();
     if (index == nullptr || index->op() != Token::BIT_AND) {
       FAIL(call_property->key(),
@@ skipping 38 matching lines @@
       fun_info->set_mutability(VariableInfo::kImmutableGlobal);
       AddForwardReference(name_var, fun_info);
       if (!ValidAsmIdentifier(name_var->name())) {
         FAIL(name_var,
              "Invalid asm.js identifier in (forward) function table name.");
       }
       if (!AddGlobal(name_var->var(), fun_info)) {
         DCHECK(false);
         FAIL(call, "Redeclared global identifier.");
       }
+      if (call->GetCallType() != Call::KEYED_PROPERTY_CALL) {
+        FAIL(call, "Invalid call of existing function table.");
+      }
       SetTypeOf(call_property, reinterpret_cast<AsmType*>(call_type));
       SetTypeOf(call, return_type);
       return return_type;
     }
 
     auto* previous_type = name_info->type()->AsFunctionTableType();
     if (previous_type == nullptr) {
       FAIL(call, "Identifier does not name a function table.");
     }
 
     if (table_length != previous_type->length()) {
       FAIL(call, "Function table size does not match expected size.");
     }
 
     auto* previous_type_signature =
         previous_type->signature()->AsFunctionType();
     DCHECK(previous_type_signature != nullptr);
     if (!previous_type_signature->CanBeInvokedWith(return_type, args)) {
       // TODO(jpp): better error messages.
       FAIL(call,
            "Function pointer table signature does not match previous "
            "signature.");
     }
 
+    if (call->GetCallType() != Call::KEYED_PROPERTY_CALL) {
+      FAIL(call, "Invalid forward call of function table.");
+    }
     SetTypeOf(call_property, previous_type->signature());
     SetTypeOf(call, return_type);
     return return_type;
   }
 
   FAIL(call, "Invalid call.");
 }
 
 // 6.10 ValidateHeapAccess
 namespace {
@@ skipping 396 matching lines @@
          "Heap view creation parameter should be the module's heap parameter.");
   }
 
   DCHECK(heap_view_info->type()->IsA(AsmType::Heap()));
   return heap_view_info->type();
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8