[wasm] Implement WebAssembly.Module.customSections.

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 2566 matching lines @@
   JSArray::SetContent(array_object, storage);
   array_object->set_length(Smi::FromInt(num_imports));
 
   Handle<JSFunction> object_function =
       Handle<JSFunction>(isolate->native_context()->object_function(), isolate);
 
   // Populate the result array.
   for (int index = 0; index < num_imports; ++index) {
     WasmImport& import = module->import_table[index];
 
-    Handle<JSObject> entry = factory->NewJSObject(object_function, TENURED);
+    Handle<JSObject> entry = factory->NewJSObject(object_function);
 
     Handle<String> import_kind;
     switch (import.kind) {
       case kExternalFunction:
         import_kind = function_string;
         break;
       case kExternalTable:
         import_kind = table_string;
         break;
       case kExternalMemory:
@@ skipping 50 matching lines @@
   JSArray::SetContent(array_object, storage);
   array_object->set_length(Smi::FromInt(num_exports));
 
   Handle<JSFunction> object_function =
       Handle<JSFunction>(isolate->native_context()->object_function(), isolate);
 
   // Populate the result array.
   for (int index = 0; index < num_exports; ++index) {
     WasmExport& exp = module->export_table[index];
 
-    Handle<JSObject> entry = factory->NewJSObject(object_function, TENURED);
-
     Handle<String> export_kind;
     switch (exp.kind) {
       case kExternalFunction:
         export_kind = function_string;
         break;
       case kExternalTable:
         export_kind = table_string;
         break;
       case kExternalMemory:
         export_kind = memory_string;
         break;
       case kExternalGlobal:
         export_kind = global_string;
         break;
       default:
         UNREACHABLE();
     }
 
+    Handle<JSObject> entry = factory->NewJSObject(object_function);
+
     MaybeHandle<String> export_name =
         WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
             isolate, compiled_module, exp.name_offset, exp.name_length);
 
     JSObject::AddProperty(entry, name_string, export_name.ToHandleChecked(),
                           NONE);
     JSObject::AddProperty(entry, kind_string, export_kind, NONE);
 
     storage->set(index, *entry);
   }
 
   return array_object;
 }
+
+Handle<JSArray> wasm::GetCustomSections(Isolate* isolate,
+                                        Handle<WasmModuleObject> module_object,
+                                        Handle<String> name) {
+  Handle<WasmCompiledModule> compiled_module(module_object->compiled_module(),
+                                             isolate);
+  Factory* factory = isolate->factory();
+
+  std::vector<CustomSectionOffset> custom_sections;
+  {
+    DisallowHeapAllocation no_gc;  // for raw access to string bytes.
+    Handle<SeqOneByteString> module_bytes(compiled_module->module_bytes(),
+                                          isolate);
+    const byte* start =
+        reinterpret_cast<const byte*>(module_bytes->GetCharsAddress());
+    const byte* end = start + module_bytes->length();
+    custom_sections = DecodeCustomSections(start, end);
+  }
+
+  std::vector<Handle<Object>> matching_sections;
+
+  // Gather matching sections.
+  for (auto section : custom_sections) {
+    MaybeHandle<String> section_name =
+        WasmCompiledModule::ExtractUtf8StringFromModuleBytes(
+            isolate, compiled_module, section.name_offset, section.name_length);
+
+    if (!name->Equals(*section_name.ToHandleChecked())) continue;
+
+    // Make a copy of the payload data in the section.
+    bool is_external;  // Set by TryAllocateBackingStore
+    void* memory = TryAllocateBackingStore(isolate, section.payload_length,
+                                           false, is_external);
+
+    Handle<Object> section_data = factory->undefined_value();
+    if (memory) {
+      Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
+      JSArrayBuffer::Setup(buffer, isolate, is_external, memory,
+                           static_cast<int>(section.payload_length));
+      DisallowHeapAllocation no_gc;  // for raw access to string bytes.
+      Handle<SeqOneByteString> module_bytes(compiled_module->module_bytes(),
+                                            isolate);
+      const byte* start =
+          reinterpret_cast<const byte*>(module_bytes->GetCharsAddress());
+      memcpy(memory, start + section.payload_offset, section.payload_length);
+      section_data = buffer;
+    } else {
+      // TODO(titzer): throw out of memory?

[rossberg, 2017/01/24 11:34:42]

Yes please.

[titzer, 2017/01/24 12:38:39]

Done.

+    }
+
+    matching_sections.push_back(section_data);
+  }
+
+  int num_custom_sections = static_cast<int>(matching_sections.size());
+  Handle<JSArray> array_object = factory->NewJSArray(FAST_ELEMENTS, 0, 0);
+  Handle<FixedArray> storage = factory->NewFixedArray(num_custom_sections);
+  JSArray::SetContent(array_object, storage);
+  array_object->set_length(Smi::FromInt(num_custom_sections));
+
+  for (int i = 0; i < num_custom_sections; i++) {
+    storage->set(i, *matching_sections[i]);
+  }
+
+  return array_object;
+}