[wasm] Lazy compilation for asm.js

src/wasm/wasm-code-specialization.cc

 // Copyright 2017 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/wasm/wasm-code-specialization.h"
 
 #include "src/assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/source-position-table.h"
 #include "src/wasm/decoder.h"
@@ skipping 43 matching lines @@
   SourcePositionTableIterator source_pos_it;
   Decoder decoder;
   const byte* func_bytes;
 };
 
 bool IsAtWasmDirectCallTarget(RelocIterator& it) {
   DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode()));
   Code* code = Code::GetCodeFromTargetAddress(it.rinfo()->target_address());
   return code->kind() == Code::WASM_FUNCTION ||
          code->kind() == Code::WASM_TO_JS_FUNCTION ||
-         code->builtin_index() == Builtins::kIllegal;
+         code->builtin_index() == Builtins::kIllegal ||
+         code->builtin_index() == Builtins::kWasmCompileLazy;
 }
 
 }  // namespace
 
 CodeSpecialization::CodeSpecialization(Isolate* isolate, Zone* zone)
     : objects_to_relocate(isolate->heap(), ZoneAllocationPolicy(zone)) {}
 
 CodeSpecialization::~CodeSpecialization() {}
 
 void CodeSpecialization::RelocateMemoryReferences(Address old_start,
@@ skipping 49 matching lines @@
                 compiled_module->module()->num_exported_functions,
             code_table->length());
 
   bool changed = false;
   int func_index = module->num_imported_functions;
 
   // Patch all wasm functions.
   for (int num_wasm_functions = static_cast<int>(wasm_functions->size());
        func_index < num_wasm_functions; ++func_index) {
     Code* wasm_function = Code::cast(code_table->get(func_index));
+    if (wasm_function->builtin_index() == Builtins::kWasmCompileLazy) continue;
     changed |= ApplyToWasmCode(wasm_function, icache_flush_mode);
   }
 
   // Patch all exported functions.
   for (auto exp : module->export_table) {
     if (exp.kind != kExternalFunction) continue;
     Code* export_wrapper = Code::cast(code_table->get(func_index));
     DCHECK_EQ(Code::JS_TO_WASM_FUNCTION, export_wrapper->kind());
     // There must be exactly one call to WASM_FUNCTION or WASM_TO_JS_FUNCTION.
     for (RelocIterator it(export_wrapper,
                           RelocInfo::ModeMask(RelocInfo::CODE_TARGET));
          ; it.next()) {
       DCHECK(!it.done());
       // Ignore calls to other builtins like ToNumber.
       if (!IsAtWasmDirectCallTarget(it)) continue;
       Code* new_code = Code::cast(code_table->get(exp.index));
-      DCHECK(new_code->kind() == Code::WASM_FUNCTION ||
-             new_code->kind() == Code::WASM_TO_JS_FUNCTION);
       it.rinfo()->set_target_address(new_code->instruction_start(),
                                      UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
       break;
     }
     changed = true;
     func_index++;
   }
   DCHECK_EQ(code_table->length(), func_index);
   return changed;
 }
@@ skipping 89 matching lines @@
             icache_flush_mode);
         changed = true;
         break;
       default:
         UNREACHABLE();
     }
   }
 
   return changed;
 }