[wasm] asm.js - Parse and convert asm.js to wasm a function at a time.

src/parsing/parser.cc

 // Copyright 2012 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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 706 matching lines @@
     log_ = &recorder;
   } else if (consume_cached_parse_data()) {
     cached_parse_data_->Initialize();
   }
 
   DeserializeScopeChain(info, info->maybe_outer_scope_info());
 
   source = String::Flatten(source);
   FunctionLiteral* result;
 
+  int start_position = info->start_position();
+  int end_position = info->end_position();
+  if (start_position == 0 && end_position == 0) {
+    end_position = source->length();
+  }
+
   {
-    std::unique_ptr<Utf16CharacterStream> stream(ScannerStream::For(source));
+    std::unique_ptr<Utf16CharacterStream> stream(
+        ScannerStream::For(source, start_position, end_position));
     scanner_.Initialize(stream.get());
     result = DoParseProgram(info);
   }
   if (result != NULL) {
-    DCHECK_EQ(scanner_.peek_location().beg_pos, source->length());
+    DCHECK_EQ(scanner_.peek_location().beg_pos, end_position);
   }
   HandleSourceURLComments(isolate, info->script());
 
   if (FLAG_trace_parse && result != NULL) {
     double ms = timer.Elapsed().InMillisecondsF();
     if (info->is_eval()) {
       PrintF("[parsing eval");
     } else if (info->script()->name()->IsString()) {
       String* name = String::cast(info->script()->name());
       std::unique_ptr<char[]> name_chars = name->ToCString();
@@ skipping 1871 matching lines @@
   // - Neither V8 natives nor native function declarations can be allowed,
   //   since parsing one would retroactively force the function to be
   //   eagerly compiled.
   // - The invoker of this parser can't depend on the AST being eagerly
   //   built (either because the function is about to be compiled, or
   //   because the AST is going to be inspected for some reason).
   // - Because of the above, we can't be attempting to parse a
   //   FunctionExpression; even without enclosing parentheses it might be
   //   immediately invoked.
   // - The function literal shouldn't be hinted to eagerly compile.
-  // - For asm.js functions the body needs to be available when module
-  //   validation is active, because we examine the entire module at once.
-
-  // Inner functions will be parsed using a temporary Zone. After parsing, we
-  // will migrate unresolved variable into a Scope in the main Zone.
-  // TODO(marja): Refactor parsing modes: simplify this.
   bool use_temp_zone =
       allow_lazy() && function_type == FunctionLiteral::kDeclaration &&
-      eager_compile_hint != FunctionLiteral::kShouldEagerCompile &&
-      !(FLAG_validate_asm && scope()->IsAsmModule());
+      eager_compile_hint != FunctionLiteral::kShouldEagerCompile;
   bool is_lazy_inner_function =
       use_temp_zone && FLAG_lazy_inner_functions && !is_lazy_top_level_function;
 
   // This Scope lives in the main zone. We'll migrate data into that zone later.
   DeclarationScope* scope = NewFunctionScope(kind);
   SetLanguageMode(scope, language_mode);
 
   ZoneList<Statement*>* body = nullptr;
   int arity = -1;
   int materialized_literal_count = -1;
@@ skipping 2797 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8