[wasm] Use weak reference for wasm deopt data.

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/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 126 matching lines @@
   // add another Internal Field as the function arity
   function->SetInternalField(kInternalArity, Smi::FromInt(arity));
   // add another Internal Field as the signature of the foreign function
   Handle<ByteArray> signature;
   if (maybe_signature.ToHandle(&signature)) {
     function->SetInternalField(kInternalSignature, *signature);
   }
   return function;
 }
 
+Object* GetOwningWasmInstance(Object* undefined, Code* code) {

[bradnelson, 2016/08/29 19:09:48]

Why pass undefined in instead of the isolate?

[Mircea Trofin, 2016/08/29 19:12:22]

Because undefined is the only needed value, rather than the whole Isolate. I
suppose Isolate would be more in-
tune with the pattern used elsewhere?

+  DCHECK(code->kind() == Code::WASM_FUNCTION);
+  DisallowHeapAllocation no_gc;
+  FixedArray* deopt_data = code->deoptimization_data();
+  DCHECK_NOT_NULL(deopt_data);
+  DCHECK(deopt_data->length() == 2);
+  Object* weak_link = deopt_data->get(0);
+  if (weak_link == undefined) return undefined;
+  WeakCell* cell = WeakCell::cast(weak_link);
+  return cell->value();
+}
+
 namespace {
 // Internal constants for the layout of the module object.
 const int kWasmModuleFunctionTable = 0;
 const int kWasmModuleCodeTable = 1;
 const int kWasmMemArrayBuffer = 2;
 const int kWasmGlobalsArrayBuffer = 3;
 // TODO(clemensh): Remove function name array, extract names from module bytes.
 const int kWasmFunctionNamesArray = 4;
 const int kWasmModuleBytesString = 5;
 const int kWasmDebugInfo = 6;
@@ skipping 270 matching lines @@
 }
 
 void FlushAssemblyCache(Isolate* isolate, Handle<FixedArray> functions) {
   for (int i = 0; i < functions->length(); ++i) {
     Handle<Code> code = functions->GetValueChecked<Code>(isolate, i);
     Assembler::FlushICache(isolate, code->instruction_start(),
                            code->instruction_size());
   }
 }
 
+void SetRuntimeSupport(Isolate* isolate, Handle<JSObject> js_object) {
+  Handle<FixedArray> functions = Handle<FixedArray>(
+      FixedArray::cast(js_object->GetInternalField(kWasmModuleCodeTable)));
+  Handle<WeakCell> weak_link = isolate->factory()->NewWeakCell(js_object);
+
+  for (int i = FLAG_skip_compiling_wasm_funcs; i < functions->length(); ++i) {
+    Handle<Code> code = functions->GetValueChecked<Code>(isolate, i);
+    DCHECK(code->deoptimization_data() == nullptr ||
+           code->deoptimization_data()->length() == 0);
+    Handle<FixedArray> deopt_data =
+        isolate->factory()->NewFixedArray(2, TENURED);
+    deopt_data->set(0, *weak_link);
+    deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
+    deopt_data->set_length(2);
+    code->set_deoptimization_data(*deopt_data);
+  }
+}
+
 }  // namespace
 
 WasmModule::WasmModule(byte* module_start)
     : module_start(module_start),
       module_end(nullptr),
       min_mem_pages(0),
       max_mem_pages(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
@@ skipping 419 matching lines @@
 
 void SetDebugSupport(Factory* factory, Handle<FixedArray> compiled_module,
                      Handle<JSObject> js_object) {
   Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> module_bytes_string =
       compiled_module->GetValue<String>(isolate, kModuleBytes);
   if (!module_bytes_string.is_null()) {
     js_object->SetInternalField(kWasmModuleBytesString,
                                 *module_bytes_string.ToHandleChecked());
   }
-  Handle<FixedArray> functions = Handle<FixedArray>(
-      FixedArray::cast(js_object->GetInternalField(kWasmModuleCodeTable)));
-
-  for (int i = FLAG_skip_compiling_wasm_funcs; i < functions->length(); ++i) {
-    Handle<Code> code = functions->GetValueChecked<Code>(isolate, i);
-    DCHECK(code->deoptimization_data() == nullptr ||
-           code->deoptimization_data()->length() == 0);
-    Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
-    if (!js_object.is_null()) {
-      deopt_data->set(0, *js_object);
-    }
-    deopt_data->set(1, Smi::FromInt(static_cast<int>(i)));
-    deopt_data->set_length(2);
-    code->set_deoptimization_data(*deopt_data);
-  }
 
   MaybeHandle<ByteArray> function_name_table =
       compiled_module->GetValue<ByteArray>(isolate, kFunctionNameTable);
   if (!function_name_table.is_null()) {
     js_object->SetInternalField(kWasmFunctionNamesArray,
                                 *function_name_table.ToHandleChecked());
   }
 }
 
 bool SetupGlobals(Isolate* isolate, Handle<FixedArray> compiled_module,
@@ skipping 489 matching lines @@
 
   if (!(SetupInstanceHeap(isolate, compiled_module, js_object, memory,
                           &thrower) &&
         SetupGlobals(isolate, compiled_module, js_object, &thrower) &&
         SetupImports(isolate, compiled_module, js_object, &thrower, ffi) &&
         SetupExportsObject(compiled_module, isolate, js_object, &thrower))) {
     return nothing;
   }
 
   SetDebugSupport(factory, compiled_module, js_object);
+  SetRuntimeSupport(isolate, js_object);
 
   FlushAssemblyCache(isolate, code_table);
 
   MaybeHandle<FixedArray> maybe_indirect_tables =
       compiled_module->GetValue<FixedArray>(isolate,
                                             kTableOfIndirectFunctionTables);
   Handle<FixedArray> indirect_tables_template;
   if (maybe_indirect_tables.ToHandle(&indirect_tables_template)) {
     Handle<FixedArray> indirect_tables = SetupIndirectFunctionTable(
         isolate, code_table, indirect_tables_template);
@@ skipping 289 matching lines @@
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower->Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8