[wasm] Skip serialization of breakpoints and certion stubs

src/wasm/wasm-module.cc

 // Copyright 2015 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 <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/adapters.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ skipping 142 matching lines @@
     DCHECK(code_table->get(i)->IsCode());
     Handle<Code> code = Handle<Code>(Code::cast(code_table->get(i)));
     AllowDeferredHandleDereference embedding_raw_address;
     int mask = 1 << RelocInfo::WASM_FUNCTION_TABLE_SIZE_REFERENCE;
     for (RelocIterator it(*code, mask); !it.done(); it.next()) {
       it.rinfo()->update_wasm_function_table_size_reference(old_size, new_size);
     }
   }
 }
 
-Handle<Code> CreatePlaceholder(Factory* factory, Code::Kind kind) {
-  byte buffer[] = {0, 0, 0, 0};  // fake instructions.
-  CodeDesc desc = {
-      buffer, arraysize(buffer), arraysize(buffer), 0, 0, nullptr, 0, nullptr};
-  return factory->NewCode(desc, Code::KindField::encode(kind),
-                          Handle<Object>::null());
-}
-
 void FlushICache(Isolate* isolate, Handle<FixedArray> code_table) {
   for (int i = 0; i < code_table->length(); ++i) {
     Handle<Code> code = code_table->GetValueChecked<Code>(isolate, i);
     Assembler::FlushICache(isolate, code->instruction_start(),
                            code->instruction_size());
   }
 }
 
 // Fetches the compilation unit of a wasm function and executes its parallel
 // phase.
@@ skipping 224 matching lines @@
     Handle<Code> code = Handle<Code>::null();
     // Compile the function.
     code = compiler::WasmCompilationUnit::CompileWasmFunction(
         thrower, isolate, module_env, &func);
     if (code.is_null()) {
       WasmName str = module_env->GetName(&func);
       thrower->CompileError("Compilation of #%d:%.*s failed.", i, str.length(),
                             str.start());
       break;
     }
-      // Install the code into the linker table.
+    // Install the code into the linker table.
     functions[i] = code;
   }
 }
 
 int ExtractDirectCallIndex(wasm::Decoder& decoder, const byte* pc) {
   DCHECK_EQ(static_cast<int>(kExprCallFunction), static_cast<int>(*pc));
   decoder.Reset(pc + 1, pc + 6);
   uint32_t call_idx = decoder.consume_u32v("call index");
   DCHECK(decoder.ok());
   DCHECK_GE(kMaxInt, call_idx);
@@ skipping 36 matching lines @@
   DCHECK_EQ(start, compiled_module->module()->num_imported_functions);
   Context* context = compiled_module->ptr_to_native_context();
   int mode_mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
 
   // Allocate decoder outside of the loop and reuse it to decode all function
   // indexes.
   wasm::Decoder decoder(nullptr, nullptr);
   int num_wasm_functions = static_cast<int>(wasm_functions->size());
   int func_index = start;
+  // We patch WASM_FUNCTION and WASM_TO_JS_FUNCTION during re-instantiation,
+  // and illegal builtins initially and after deserialization.
+  auto is_at_wasm_call = [](RelocIterator& it) {
+    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;
+  };
+
   // Patch all wasm functions.
   for (; func_index < num_wasm_functions; ++func_index) {
     Code* wasm_function = Code::cast(new_functions->get(func_index));
     DCHECK(wasm_function->kind() == Code::WASM_FUNCTION);
     // Iterate simultaneously over the relocation information and the source
     // position table. For each call in the reloc info, move the source position
     // iterator forward to that position to find the byte offset of the
     // respective call. Then extract the call index from the module wire bytes
     // to find the new compiled function.
     SourcePositionTableIterator source_pos_iterator(
         wasm_function->source_position_table());
     const byte* func_bytes =
         module_bytes->GetChars() +
         compiled_module->module()->functions[func_index].code_start_offset;
     for (RelocIterator it(wasm_function, mode_mask); !it.done(); it.next()) {
       if (RelocInfo::IsEmbeddedObject(it.rinfo()->rmode())) {
         PatchContext(it, context);
         continue;
       }
       DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode()));
-      Code::Kind kind =
-          Code::GetCodeFromTargetAddress(it.rinfo()->target_address())->kind();
-      if (kind != Code::WASM_FUNCTION && kind != Code::WASM_TO_JS_FUNCTION)
-        continue;
+      if (!is_at_wasm_call(it)) continue;
       size_t offset = it.rinfo()->pc() - wasm_function->instruction_start();
       int byte_pos =
           AdvanceSourcePositionTableIterator(source_pos_iterator, offset);
       int called_func_index =
           ExtractDirectCallIndex(decoder, func_bytes + byte_pos);
       Code* new_code = Code::cast(new_functions->get(called_func_index));
       it.rinfo()->set_target_address(new_code->instruction_start(),
                                      UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
     }
   }
   // Patch all exported functions.
   for (auto exp : module->export_table) {
     if (exp.kind != kExternalFunction) continue;
     Code* export_wrapper = Code::cast(new_functions->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.
     int num_wasm_calls = 0;
     for (RelocIterator it(export_wrapper, mode_mask); !it.done(); it.next()) {
       if (RelocInfo::IsEmbeddedObject(it.rinfo()->rmode())) {
         PatchContext(it, context);
         continue;
       }
       DCHECK(RelocInfo::IsCodeTarget(it.rinfo()->rmode()));
-      Code::Kind kind =
-          Code::GetCodeFromTargetAddress(it.rinfo()->target_address())->kind();
-      if (kind != Code::WASM_FUNCTION && kind != Code::WASM_TO_JS_FUNCTION)
-        continue;
+      if (!is_at_wasm_call(it)) continue;
       ++num_wasm_calls;
       Code* new_code = Code::cast(new_functions->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);
     }
     DCHECK_EQ(1, num_wasm_calls);
     func_index++;
   }
@@ skipping 386 matching lines @@
 
   ModuleBytesEnv module_env(this, &temp_instance, wire_bytes);
 
   // The {code_table} array contains import wrappers and functions (which
   // are both included in {functions.size()}, and export wrappers.
   int code_table_size =
       static_cast<int>(functions.size() + num_exported_functions);
   Handle<FixedArray> code_table =
       factory->NewFixedArray(static_cast<int>(code_table_size), TENURED);
 
-  // Initialize the code table with placeholders.
-  Handle<Code> code_placeholder =
-      CreatePlaceholder(factory, Code::WASM_FUNCTION);
+  // Initialize the code table with the illegal builtin. All call sites will be
+  // patched at instantiation.
+  Handle<Code> illegal_builtin = isolate->builtins()->Illegal();
   for (uint32_t i = 0; i < functions.size(); ++i) {
-    code_table->set(static_cast<int>(i), *code_placeholder);
-    temp_instance.function_code[i] = code_placeholder;
+    code_table->set(static_cast<int>(i), *illegal_builtin);
+    temp_instance.function_code[i] = illegal_builtin;
   }
 
   isolate->counters()->wasm_functions_per_module()->AddSample(
       static_cast<int>(functions.size()));
   if (!FLAG_trace_wasm_decoder && FLAG_wasm_num_compilation_tasks != 0) {
     // Avoid a race condition by collecting results into a second vector.
-    std::vector<Handle<Code>> results;
-    results.reserve(temp_instance.function_code.size());
-    for (size_t i = 0; i < temp_instance.function_code.size(); ++i) {
-      results.push_back(temp_instance.function_code[i]);
-    }
+    std::vector<Handle<Code>> results(temp_instance.function_code);
     CompileInParallel(isolate, &module_env, results, thrower);
-
-    for (size_t i = 0; i < results.size(); ++i) {
-      temp_instance.function_code[i] = results[i];
-    }
+    temp_instance.function_code.swap(results);
   } else {
     CompileSequentially(isolate, &module_env, temp_instance.function_code,
                         thrower);
   }
   if (thrower->error()) return nothing;
 
   // At this point, compilation has completed. Update the code table.
   for (size_t i = FLAG_skip_compiling_wasm_funcs;
        i < temp_instance.function_code.size(); ++i) {
     Code* code = *temp_instance.function_code[i];
@@ skipping 1610 matching lines @@
 
     JSObject::AddProperty(entry, name_string, export_name.ToHandleChecked(),
                           NONE);
     JSObject::AddProperty(entry, kind_string, export_kind, NONE);
 
     storage->set(index, *entry);
   }
 
   return array_object;
 }