Heap::CopyCode handling of references into NEW_SPACE

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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
@@ skipping 990 matching lines @@
   MaybeHandle<FixedArray> nothing;
 
   WasmModuleInstance temp_instance_for_compilation(this);
   temp_instance_for_compilation.context = isolate->native_context();
   temp_instance_for_compilation.mem_size = GetMinModuleMemSize(this);
   temp_instance_for_compilation.mem_start = nullptr;
   temp_instance_for_compilation.globals_start = nullptr;
 
   MaybeHandle<FixedArray> indirect_table =
       function_tables.size()
-          ? factory->NewFixedArray(static_cast<int>(function_tables.size()))
+          ? factory->NewFixedArray(static_cast<int>(function_tables.size()),
+                                   TENURED)
           : MaybeHandle<FixedArray>();
   for (uint32_t i = 0; i < function_tables.size(); ++i) {
     Handle<FixedArray> values = wasm::BuildFunctionTable(isolate, i, this);
     temp_instance_for_compilation.function_tables[i] = values;
 
     Handle<FixedArray> metadata = isolate->factory()->NewFixedArray(
-        kWasmIndirectFunctionTableMetadataSize);
+        kWasmIndirectFunctionTableMetadataSize, TENURED);
     metadata->set(kSize, Smi::FromInt(function_tables[i].size));
     metadata->set(kTable, *values);
     indirect_table.ToHandleChecked()->set(i, *metadata);
   }
 
   HistogramTimerScope wasm_compile_module_time_scope(
       isolate->counters()->wasm_compile_module_time());
 
   ModuleEnv module_env;
   module_env.module = this;
@@ skipping 132 matching lines @@
   CHECK(seen);
   Assembler::FlushICache(isolate, wrapper->instruction_start(),
                          wrapper->instruction_size());
 }
 
 Handle<FixedArray> CloneModuleForInstance(Isolate* isolate,
                                           Handle<FixedArray> original) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> clone = factory->CopyFixedArray(original);
 
+  // Clone each wasm code object.
+  Handle<FixedArray> orig_wasm_functions =
+      original->GetValueChecked<FixedArray>(isolate, kFunctions);
+  Handle<FixedArray> clone_wasm_functions =
+      factory->CopyFixedArray(orig_wasm_functions);
+  clone->set(kFunctions, *clone_wasm_functions);
+  for (int i = 0; i < clone_wasm_functions->length(); ++i) {
+    Handle<Code> orig_code =
+        clone_wasm_functions->GetValueChecked<Code>(isolate, i);
+    Handle<Code> cloned_code = factory->CopyCode(orig_code);
+    clone_wasm_functions->set(i, *cloned_code);
+  }
+
   // Copy the outer table, each WasmIndirectFunctionTableMetadata table, and the
   // inner kTable.
   MaybeHandle<FixedArray> maybe_indirect_tables =
       original->GetValue<FixedArray>(isolate, kTableOfIndirectFunctionTables);
   Handle<FixedArray> indirect_tables, clone_indirect_tables;
   if (maybe_indirect_tables.ToHandle(&indirect_tables)) {
     clone_indirect_tables = factory->CopyFixedArray(indirect_tables);
     clone->set(kTableOfIndirectFunctionTables, *clone_indirect_tables);
     for (int i = 0; i < clone_indirect_tables->length(); ++i) {
       Handle<FixedArray> orig_metadata =
           clone_indirect_tables->GetValueChecked<FixedArray>(isolate, i);
       Handle<FixedArray> clone_metadata =
           factory->CopyFixedArray(orig_metadata);
       clone_indirect_tables->set(i, *clone_metadata);
 
       Handle<FixedArray> orig_table =
           clone_metadata->GetValueChecked<FixedArray>(isolate, kTable);
       Handle<FixedArray> clone_table = factory->CopyFixedArray(orig_table);
       clone_metadata->set(kTable, *clone_table);
-    }
-  }
-
-  // Clone each code, then if indirect tables are used, patch the cloned code to
-  // refer to the cloned kTable.
-  Handle<FixedArray> orig_wasm_functions =
-      original->GetValueChecked<FixedArray>(isolate, kFunctions);
-  Handle<FixedArray> clone_wasm_functions =
-      factory->CopyFixedArray(orig_wasm_functions);
-  clone->set(kFunctions, *clone_wasm_functions);
-  for (int i = 0; i < clone_wasm_functions->length(); ++i) {
-    Handle<Code> orig_code =
-        clone_wasm_functions->GetValueChecked<Code>(isolate, i);
-    Handle<Code> cloned_code = factory->CopyCode(orig_code);
-    clone_wasm_functions->set(i, *cloned_code);
-
-    if (!clone_indirect_tables.is_null()) {
-      for (int j = 0; j < clone_indirect_tables->length(); ++j) {

[bradnelson, 2016/08/02 22:47:14]

I think you want to keep this.

[bradnelson, 2016/08/02 22:48:54]

Nm, this got pulled into the loop above.

-        Handle<FixedArray> orig_metadata =
-            indirect_tables->GetValueChecked<FixedArray>(isolate, j);
-        Handle<FixedArray> orig_table =
-            orig_metadata->GetValueChecked<FixedArray>(isolate, kTable);
-
-        Handle<FixedArray> clone_metadata =
-            clone_indirect_tables->GetValueChecked<FixedArray>(isolate, j);
-        Handle<FixedArray> clone_table =
-            clone_metadata->GetValueChecked<FixedArray>(isolate, kTable);
-
+      // Patch the cloned code to refer to the cloned kTable.
+      for (int i = 0; i < clone_wasm_functions->length(); ++i) {
+        Handle<Code> cloned_code =
+            clone_wasm_functions->GetValueChecked<Code>(isolate, i);
         PatchFunctionTable(cloned_code, orig_table, clone_table);
       }
     }
   }
 
   MaybeHandle<FixedArray> maybe_orig_exports =
       original->GetValue<FixedArray>(isolate, kExports);
   Handle<FixedArray> orig_exports;
   if (maybe_orig_exports.ToHandle(&orig_exports)) {
     Handle<FixedArray> cloned_exports = factory->CopyFixedArray(orig_exports);
@@ skipping 258 matching lines @@
   }
   return true;
 }
 
 Handle<FixedArray> BuildFunctionTable(Isolate* isolate, uint32_t index,
                                       const WasmModule* module) {
   const WasmIndirectFunctionTable* table = &module->function_tables[index];
   DCHECK_EQ(table->size, table->values.size());
   DCHECK_GE(table->max_size, table->size);
   Handle<FixedArray> values =
-      isolate->factory()->NewFixedArray(2 * table->max_size);
+      isolate->factory()->NewFixedArray(2 * table->max_size, TENURED);
   for (uint32_t i = 0; i < table->size; ++i) {
     const WasmFunction* function = &module->functions[table->values[i]];
     values->set(i, Smi::FromInt(function->sig_index));
     values->set(i + table->max_size, Smi::FromInt(table->values[i]));
   }
   // Set the remaining elements to -1 (instead of "undefined"). These
   // elements are accessed directly as SMIs (without a check). On 64-bit
   // platforms, it is possible to have the top bits of "undefined" take
   // small integer values (or zero), which are more likely to be equal to
   // the signature index we check against.
@@ skipping 89 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