[wasm] Base address for data segments can also be the value of a global variable.

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 72 matching lines @@
 
 enum WasmGlobalInitData {
   kGlobalInitKind,   // 0 = constant, 1 = global index
   kGlobalInitType,   // Smi. Type for globals.
   kGlobalInitIndex,  // Smi, an uint32_t
   kGlobalInitValue,  // Number.
   kWasmGlobalInitDataSize
 };
 
 enum WasmSegmentInfo {
-  kDestInitKind,        // 0 = constant, 1 = global index
+  kDestAddrKind,        // 0 = constant, 1 = global index
   kDestAddrValue,       // Smi. an uint32_t
   kSourceSize,          // Smi. an uint32_t
   kWasmSegmentInfoSize  // Sentinel value.
 };
 
 enum WasmIndirectFunctionTableData {
   kSize,                              // Smi. an uint32_t
   kTable,                             // FixedArray of indirect function table
   kWasmIndirectFunctionTableDataSize  // Sentinel value.
 };
@@ skipping 16 matching lines @@
     data_size += segment.source_size;
   }
   Handle<ByteArray> data = factory->NewByteArray(data_size, TENURED);
 
   uint32_t last_insertion_pos = 0;
   for (uint32_t i = 0; i < module->data_segments.size(); ++i) {
     const WasmDataSegment& segment = module->data_segments[i];
     if (segment.source_size == 0) continue;
     Handle<ByteArray> js_segment =
         factory->NewByteArray(kWasmSegmentInfoSize * sizeof(uint32_t), TENURED);
-    // TODO(titzer): add support for global offsets for dest_addr
-    CHECK_EQ(WasmInitExpr::kI32Const, segment.dest_addr.kind);
-    js_segment->set_int(kDestAddrValue, segment.dest_addr.val.i32_const);
+    if (segment.dest_addr.kind == WasmInitExpr::kGlobalIndex) {
+      // The destination address is the value of a global variable.
+      js_segment->set_int(kDestAddrKind, 1);
+      uint32_t offset =
+          module->globals[segment.dest_addr.val.global_index].offset;
+      js_segment->set_int(kDestAddrValue, static_cast<int>(offset));
+    } else {
+      // The destination address is a constant.
+      CHECK_EQ(WasmInitExpr::kI32Const, segment.dest_addr.kind);
+      js_segment->set_int(kDestAddrKind, 0);
+      js_segment->set_int(kDestAddrValue, segment.dest_addr.val.i32_const);
+    }
     js_segment->set_int(kSourceSize, segment.source_size);
     segments->set(i, *js_segment);
     data->copy_in(last_insertion_pos,
                   module->module_start + segment.source_offset,
                   segment.source_size);
     last_insertion_pos += segment.source_size;
   }
   compiled_module->set_data_segments_info(segments);
   compiled_module->set_data_segments(data);
 }
@@ skipping 1126 matching lines @@
       instance->SetInternalField(kWasmGlobalsArrayBuffer, *global_buffer);
     }
 
     //--------------------------------------------------------------------------
     // Process the imports for the module.
     //--------------------------------------------------------------------------
     int num_imported_functions = ProcessImports(globals, code_table, instance);
     if (num_imported_functions < 0) return nothing;
 
     //--------------------------------------------------------------------------
+    // Process the initialization for the module's globals.
+    //--------------------------------------------------------------------------
+    ProcessInits(globals);
+
+    //--------------------------------------------------------------------------
     // Set up the memory for the new instance.
     //--------------------------------------------------------------------------
     MaybeHandle<JSArrayBuffer> old_memory;
     // TODO(titzer): handle imported memory properly.
 
     uint32_t min_mem_pages = compiled_module_->min_memory_pages();
     isolate_->counters()->wasm_min_mem_pages_count()->AddSample(min_mem_pages);
     // TODO(wasm): re-enable counter for max_mem_pages when we use that field.
 
     if (memory_.is_null() && min_mem_pages > 0) {
       memory_ = AllocateMemory(min_mem_pages);
       if (memory_.is_null()) return nothing;  // failed to allocate memory
     }
 
     if (!memory_.is_null()) {
       instance->SetInternalField(kWasmMemArrayBuffer, *memory_);
       Address mem_start = static_cast<Address>(memory_->backing_store());
       uint32_t mem_size =
           static_cast<uint32_t>(memory_->byte_length()->Number());
-      LoadDataSegments(mem_start, mem_size);
+      LoadDataSegments(globals, mem_start, mem_size);
 
       uint32_t old_mem_size = compiled_module_->has_heap()
                                   ? compiled_module_->mem_size()
                                   : compiled_module_->default_mem_size();
       Address old_mem_start =
           compiled_module_->has_heap()
               ? static_cast<Address>(compiled_module_->heap()->backing_store())
               : nullptr;
       RelocateInstanceCode(instance, old_mem_start, mem_start, old_mem_size,
                            mem_size);
       compiled_module_->set_heap(memory_);
     }
 
     //--------------------------------------------------------------------------
-    // Process the initialization for the module's globals.
-    //--------------------------------------------------------------------------
-    ProcessInits(globals);
-
-    //--------------------------------------------------------------------------
     // Set up the runtime support for the new instance.
     //--------------------------------------------------------------------------
     Handle<WeakCell> weak_link = factory->NewWeakCell(instance);
 
     for (int i = num_imported_functions + FLAG_skip_compiling_wasm_funcs;
          i < code_table->length(); ++i) {
       Handle<Code> code = code_table->GetValueChecked<Code>(isolate_, i);
       if (code->kind() == Code::WASM_FUNCTION) {
         Handle<FixedArray> deopt_data = factory->NewFixedArray(2, TENURED);
         deopt_data->set(0, *weak_link);
@@ skipping 167 matching lines @@
       }
     } else {
       // No function specified. Use the "default export".
       result = module;
     }
 
     return result;
   }
 
   // Load data segments into the memory.
-  void LoadDataSegments(Address mem_addr, size_t mem_size) {
+  void LoadDataSegments(MaybeHandle<JSArrayBuffer> globals, Address mem_addr,
+                        size_t mem_size) {
     CHECK(compiled_module_->has_data_segments() ==
           compiled_module_->has_data_segments_info());
 
     // If we have neither, we're done.
     if (!compiled_module_->has_data_segments()) return;
 
     Handle<ByteArray> data = compiled_module_->data_segments();
     Handle<FixedArray> segments = compiled_module_->data_segments_info();
 
     uint32_t last_extraction_pos = 0;
     for (int i = 0; i < segments->length(); ++i) {
       Handle<ByteArray> segment =
           Handle<ByteArray>(ByteArray::cast(segments->get(i)));
       uint32_t dest_addr =
           static_cast<uint32_t>(segment->get_int(kDestAddrValue));
+      if (segment->get_int(kDestAddrKind) == 1) {
+        // The destination address is the value of a global variable.
+        dest_addr =
+            *reinterpret_cast<uint32_t*>(raw_buffer_ptr(globals, dest_addr));
+      }
+
       uint32_t source_size =
           static_cast<uint32_t>(segment->get_int(kSourceSize));
       CHECK_LT(dest_addr, mem_size);
       CHECK_LE(source_size, mem_size);
       CHECK_LE(dest_addr, mem_size - source_size);
       byte* addr = mem_addr + dest_addr;
       data->copy_out(last_extraction_pos, addr, source_size);
       last_extraction_pos += source_size;
     }
   }
@@ skipping 720 matching lines @@
   WasmCompiledModule* compiled_module =
       WasmCompiledModule::cast(instance->GetInternalField(kWasmCompiledModule));
   CHECK(compiled_module->has_weak_module_object());
   CHECK(compiled_module->ptr_to_weak_module_object()->cleared());
 }
 
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8