Disentangle assembler from isolate.

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 131 matching lines @@
     // 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(),
+      it.rinfo()->set_target_address(new_code->GetIsolate(),
+                                     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 21 matching lines @@
   add_mode(reloc_objects, RelocInfo::EMBEDDED_OBJECT);
 
   std::unique_ptr<PatchDirectCallsHelper> patch_direct_calls_helper;
   bool changed = false;
 
   for (RelocIterator it(code, reloc_mode); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
     switch (mode) {
       case RelocInfo::WASM_MEMORY_REFERENCE:
         DCHECK(reloc_mem_addr);
-        it.rinfo()->update_wasm_memory_reference(old_mem_start, new_mem_start,
+        it.rinfo()->update_wasm_memory_reference(code->GetIsolate(),
+                                                 old_mem_start, new_mem_start,
                                                  icache_flush_mode);
         changed = true;
         break;
       case RelocInfo::WASM_MEMORY_SIZE_REFERENCE:
         DCHECK(reloc_mem_size);
-        it.rinfo()->update_wasm_memory_size(old_mem_size, new_mem_size,
-                                            icache_flush_mode);
+        it.rinfo()->update_wasm_memory_size(code->GetIsolate(), old_mem_size,
+                                            new_mem_size, icache_flush_mode);
         changed = true;
         break;
       case RelocInfo::WASM_GLOBAL_REFERENCE:
         DCHECK(reloc_globals);
         it.rinfo()->update_wasm_global_reference(
-            old_globals_start, new_globals_start, icache_flush_mode);
+            code->GetIsolate(), old_globals_start, new_globals_start,
+            icache_flush_mode);
         changed = true;
         break;
       case RelocInfo::CODE_TARGET: {
         DCHECK(reloc_direct_calls);
         // Skip everything which is not a wasm call (stack checks, traps, ...).
         if (!IsAtWasmDirectCallTarget(it)) continue;
         // 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.
         size_t offset = it.rinfo()->pc() - code->instruction_start();
         if (!patch_direct_calls_helper) {
           patch_direct_calls_helper.reset(new PatchDirectCallsHelper(
               *relocate_direct_calls_instance, code));
         }
         int byte_pos = AdvanceSourcePositionTableIterator(
             patch_direct_calls_helper->source_pos_it, offset);
         int called_func_index = ExtractDirectCallIndex(
             patch_direct_calls_helper->decoder,
             patch_direct_calls_helper->func_bytes + byte_pos);
         FixedArray* code_table =
             relocate_direct_calls_instance->compiled_module()
                 ->ptr_to_code_table();
         Code* new_code = Code::cast(code_table->get(called_func_index));
-        it.rinfo()->set_target_address(new_code->instruction_start(),
+        it.rinfo()->set_target_address(new_code->GetIsolate(),
+                                       new_code->instruction_start(),
                                        UPDATE_WRITE_BARRIER, icache_flush_mode);
         changed = true;
       } break;
       case RelocInfo::EMBEDDED_OBJECT: {
         DCHECK(reloc_objects);
         Object* old = it.rinfo()->target_object();
         Handle<Object>* new_obj = objects_to_relocate.Find(old);
         if (new_obj) {
           it.rinfo()->set_target_object(HeapObject::cast(**new_obj),
                                         UPDATE_WRITE_BARRIER,
                                         icache_flush_mode);
           changed = true;
         }
       } break;
       case RelocInfo::WASM_FUNCTION_TABLE_SIZE_REFERENCE:
         DCHECK(patch_table_size);
         it.rinfo()->update_wasm_function_table_size_reference(
-            old_function_table_size, new_function_table_size,
-            icache_flush_mode);
+            code->GetIsolate(), old_function_table_size,
+            new_function_table_size, icache_flush_mode);
         changed = true;
         break;
       default:
         UNREACHABLE();
     }
   }
 
   return changed;
 }