[wasm] Patch the native context embedded in compiled code

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 449 matching lines @@
   int offset = static_cast<int>(offset_l);
   DCHECK(!iterator.done());
   int byte_pos;
   do {
     byte_pos = iterator.source_position().ScriptOffset();
     iterator.Advance();
   } while (!iterator.done() && iterator.code_offset() <= offset);
   return byte_pos;
 }
 
-void PatchDirectCalls(Handle<FixedArray> new_functions,
-                      Handle<WasmCompiledModule> compiled_module,
-                      WasmModule* module, int start) {
+void PatchContext(RelocIterator& it, Context* context) {
+  Object* old = it.rinfo()->target_object();
+  // The only context we use is the native context.
+  DCHECK_IMPLIES(old->IsContext(), old->IsNativeContext());
+  if (!old->IsNativeContext()) return;
+  it.rinfo()->set_target_object(context, UPDATE_WRITE_BARRIER,
+                                SKIP_ICACHE_FLUSH);
+}
+
+void PatchDirectCallsAndContext(Handle<FixedArray> new_functions,
+                                Handle<WasmCompiledModule> compiled_module,
+                                WasmModule* module, int start) {
   DisallowHeapAllocation no_gc;
   AllowDeferredHandleDereference embedding_raw_address;
   SeqOneByteString* module_bytes = compiled_module->module_bytes();
   std::vector<WasmFunction>* wasm_functions =
       &compiled_module->module()->functions;
   DCHECK_EQ(wasm_functions->size() +
                 compiled_module->module()->num_exported_functions,
             new_functions->length());
   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;
   // 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, RelocInfo::kCodeTargetMask);
-         !it.done(); it.next()) {
+    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;
       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, RelocInfo::kCodeTargetMask);
-         !it.done(); it.next()) {
+    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;
       ++num_wasm_calls;
       Code* new_code = Code::cast(new_functions->get(exp.index));
       DCHECK_EQ(kind, new_code->kind());
       it.rinfo()->set_target_address(new_code->instruction_start(),
                                      UPDATE_WRITE_BARRIER, SKIP_ICACHE_FLUSH);
     }
@@ skipping 693 matching lines @@
           }
         }
         RecordStats(isolate_, code_table);
       } else {
         // There was no owner, so we can reuse the original.
         compiled_module_ = original;
         TRACE("Reusing existing instance %d\n",
               compiled_module_->instance_id());
       }
       compiled_module_->set_code_table(code_table);
+      compiled_module_->set_native_context(isolate_->native_context());
     }
     module_ = compiled_module_->module();
 
     //--------------------------------------------------------------------------
     // Allocate the instance object.
     //--------------------------------------------------------------------------
     Handle<WasmInstanceObject> instance =
         WasmInstanceObject::New(isolate_, compiled_module_);
 
     //--------------------------------------------------------------------------
@@ skipping 109 matching lines @@
     DCHECK(wasm::IsWasmInstance(*instance));
     if (instance->has_memory_object()) {
       instance->memory_object()->AddInstance(isolate_, instance);
     }
 
     //--------------------------------------------------------------------------
     // Set up the indirect function tables for the new instance.
     //--------------------------------------------------------------------------
     if (function_table_count > 0) InitializeTables(code_table, instance);
 
-    if (num_imported_functions > 0 || !owner.is_null()) {
-      // If the code was cloned, or new imports were compiled, patch.
-      PatchDirectCalls(code_table, compiled_module_, module_,
-                       num_imported_functions);
-    }
+    // Patch new call sites and the context.
+    PatchDirectCallsAndContext(code_table, compiled_module_, module_,
+                               num_imported_functions);
 
     FlushICache(isolate_, code_table);
 
     //--------------------------------------------------------------------------
     // Unpack and notify signal handler of protected instructions.
     //--------------------------------------------------------------------------
     {
       for (int i = 0; i < code_table->length(); ++i) {
         Handle<Code> code = code_table->GetValueChecked<Code>(isolate_, i);
 
@@ skipping 1137 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;
 }