[wasm] disable serialization for asm-wasm

src/compiler.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/compiler.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
@@ skipping 1327 matching lines @@
   if (callback == NULL) {
     // No callback set and code generation disallowed.
     return false;
   } else {
     // Callback set. Let it decide if code generation is allowed.
     VMState<EXTERNAL> state(isolate);
     return callback(v8::Utils::ToLocal(context));
   }
 }
 
+bool ContainsAsmModule(const Scope* scope, Zone* zone) {
+  DCHECK_NOT_NULL(scope);
+  DCHECK_NOT_NULL(zone);
+  ZoneQueue<const Scope*> worklist(zone);
+  // We assume scopes form a tree, so no need to check for cycles

[Yang, 2016/12/15 05:41:09]

I think this can be done a lot easier. We have all shared function infos that
have been compiled in GetSharedFunctionInfoForScript listed in
Script::shared_function_infos. You can iterate through it using
WeakFixedArray::Iterator. There you can figure out whether there is an asm
module involved.

+  worklist.push(scope);
+  while (!worklist.empty()) {
+    const Scope* s = worklist.front();
+    worklist.pop();
+    if (s->IsAsmModule()) {
+      return true;
+    }
+    for (const Scope* child = s->inner_scope(); child != nullptr;
+         child = child->sibling()) {
+      worklist.push(child);
+    }
+  }
+  return false;
+}
+
 }  // namespace
 
 MaybeHandle<JSFunction> Compiler::GetFunctionFromString(
     Handle<Context> context, Handle<String> source,
     ParseRestriction restriction) {
   Isolate* const isolate = context->GetIsolate();
   Handle<Context> native_context(context->native_context(), isolate);
 
   // Check if native context allows code generation from
   // strings. Throw an exception if it doesn't.
@@ skipping 121 matching lines @@
         compile_options == ScriptCompiler::kProduceCodeCache) {
       info.PrepareForSerializing();
     }
 
     parse_info.set_language_mode(
         static_cast<LanguageMode>(parse_info.language_mode() | language_mode));
     result = CompileToplevel(&info);
     if (extension == NULL && !result.is_null()) {
       compilation_cache->PutScript(source, context, language_mode, result);
       if (FLAG_serialize_toplevel &&
-          compile_options == ScriptCompiler::kProduceCodeCache) {
+          compile_options == ScriptCompiler::kProduceCodeCache &&
+          !ContainsAsmModule(info.scope(), &zone)) {
         HistogramTimerScope histogram_timer(
             isolate->counters()->compile_serialize());
         RuntimeCallTimerScope runtimeTimer(isolate,
                                            &RuntimeCallStats::CompileSerialize);
         TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.compile"),
                      "V8.CompileSerialize");
         *cached_data = CodeSerializer::Serialize(isolate, result, source);
         if (FLAG_profile_deserialization) {
           PrintF("[Compiling and serializing took %0.3f ms]\n",
                  timer.Elapsed().InMillisecondsF());
@@ skipping 225 matching lines @@
     DCHECK(shared->is_compiled());
     function->set_literals(cached.literals);
   } else if (shared->is_compiled()) {
     // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
     JSFunction::EnsureLiterals(function);
   }
 }
 
 }  // namespace internal
 }  // namespace v8