[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 841 matching lines @@
                                       &RuntimeCallStats::ParseFunction);
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"), "V8.ParseFunction");
   Handle<String> source(String::cast(info->script()->source()));
   isolate->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
   Handle<SharedFunctionInfo> shared_info = info->shared_info();
   DeserializeScopeChain(info, info->maybe_outer_scope_info());
+  if (info->asm_function_scope()) {
+    original_scope_ = info->asm_function_scope();
+    factory()->set_zone(info->zone());

[marja, 2016/11/29 10:20:04]

I was debating with myself whether the set_zone should be inside this if.

I guess it's fine; could you add here:

else {
  DCHECK(factory()->zone() == info->zone());
}

[bradn, 2016/11/29 10:43:36]

Done.

+  }
 
   // Initialize parser state.
   source = String::Flatten(source);
   FunctionLiteral* result;
   {
     std::unique_ptr<Utf16CharacterStream> stream(ScannerStream::For(
         source, shared_info->start_position(), shared_info->end_position()));
     Handle<String> name(String::cast(shared_info->name()));
     result = DoParseFunction(info, ast_value_factory()->GetString(name),
                              stream.get());
@@ skipping 29 matching lines @@
                                          const AstRawString* raw_name,
                                          Utf16CharacterStream* source) {
   scanner_.Initialize(source);
   DCHECK_NULL(scope_state_);
   DCHECK_NULL(target_stack_);
 
   DCHECK(ast_value_factory());
   fni_ = new (zone()) FuncNameInferrer(ast_value_factory(), zone());
   fni_->PushEnclosingName(raw_name);
 
-  ResetFunctionLiteralId();
-  DCHECK_LT(0, info->function_literal_id());
-  SkipFunctionLiterals(info->function_literal_id() - 1);
+  // Asm functions don't get IDs.

[marja, 2016/11/29 10:20:04]

Why? Is it bad if we assign IDs to them? And what does this mean for the rest of
the code (not just DoParseFunction); don't we need to adapt the rest of the ID
getting code too? (jochen@ can comment on that better)

[bradn, 2016/11/29 10:43:36]

Fair point.
Setting an id for them instead of this and below.

+  if (!info->asm_function_scope()) {
+    ResetFunctionLiteralId();
+    DCHECK_LT(0, info->function_literal_id());
+    SkipFunctionLiterals(info->function_literal_id() - 1);
+  }
 
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
     Scope* outer = original_scope_;
     DeclarationScope* outer_function = outer->GetClosureScope();
@@ skipping 112 matching lines @@
           raw_name, Scanner::Location::invalid(), kSkipFunctionNameCheck, kind,
           kNoSourcePosition, function_type, info->language_mode(), &ok);
       if (info->requires_class_field_init()) {
         result = InsertClassFieldInitializer(result);
       }
     }
     // Make sure the results agree.
     DCHECK(ok == (result != nullptr));
   }
 
-  // Make sure the target stack is empty.
-  DCHECK_NULL(target_stack_);
-  DCHECK_IMPLIES(result,
-                 info->function_literal_id() == result->function_literal_id());
+  // Asm functions don't get IDs.
+  if (!info->asm_function_scope()) {
+    // Make sure the target stack is empty.
+    DCHECK_NULL(target_stack_);
+    DCHECK_IMPLIES(
+        result, info->function_literal_id() == result->function_literal_id());
+  }
   return result;
 }
 
 Statement* Parser::ParseModuleItem(bool* ok) {
   // ecma262/#prod-ModuleItem
   // ModuleItem :
   //    ImportDeclaration
   //    ExportDeclaration
   //    StatementListItem
 
@@ skipping 1564 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 =
       (FLAG_lazy_inner_functions
            ? can_preparse
            : (is_lazy_top_level_function ||
               (allow_lazy_ && function_type == FunctionLiteral::kDeclaration &&
-               eager_compile_hint == FunctionLiteral::kShouldLazyCompile))) &&
-      !(FLAG_validate_asm && scope()->IsAsmModule());
+               eager_compile_hint == FunctionLiteral::kShouldLazyCompile)));
   bool is_lazy_inner_function =
       use_temp_zone && FLAG_lazy_inner_functions && !is_lazy_top_level_function;
 
   ZoneList<Statement*>* body = nullptr;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   bool should_be_used_once_hint = false;
   int num_parameters = -1;
   int function_length = -1;
   bool has_duplicate_parameters = false;
@@ skipping 2840 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8