[wasm] JS APIs & memory

src/wasm/module-decoder.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 "src/wasm/module-decoder.h"
 
 #include "src/base/functional.h"
 #include "src/base/platform/platform.h"
 #include "src/flags.h"
 #include "src/macro-assembler.h"
@@ skipping 306 matching lines @@
                                      &table->max_size);
             break;
           }
           case kExternalMemory: {
             // ===== Imported memory =========================================
             bool has_max = false;
             consume_resizable_limits("memory", "pages", kV8MaxWasmMemoryPages,
                                      &module->min_mem_pages, &has_max,
                                      kSpecMaxWasmMemoryPages,
                                      &module->max_mem_pages);
-            if (module->has_memory) {
-              error("At most one memory object is supported");
-            } else {
-              module->has_memory = true;
-            }
+            SetHasMemory(module);
             break;
           }
           case kExternalGlobal: {
             // ===== Imported global =========================================
             import->index = static_cast<uint32_t>(module->globals.size());
             module->globals.push_back(
                 {kWasmStmt, false, WasmInitExpr(), 0, true, false});
             WasmGlobal* global = &module->globals.back();
             global->type = consume_value_type();
             global->mutability = consume_u8("mutability") != 0;
@@ skipping 54 matching lines @@
     // ===== Memory section ==================================================
     if (section_iter.section_code() == kMemorySectionCode) {
       uint32_t memory_count = consume_count("memory count", kV8MaxWasmMemories);
 
       for (uint32_t i = 0; ok() && i < memory_count; i++) {
         bool has_max = false;
         consume_resizable_limits(
             "memory", "pages", kV8MaxWasmMemoryPages, &module->min_mem_pages,
             &has_max, kSpecMaxWasmMemoryPages, &module->max_mem_pages);
       }
-      module->has_memory = true;
+      SetHasMemory(module);
       section_iter.advance();
     }
 
     // ===== Global section ==================================================
     if (section_iter.section_code() == kGlobalSectionCode) {
       uint32_t globals_count =
           consume_count("globals count", kV8MaxWasmGlobals);
       uint32_t imported_globals = static_cast<uint32_t>(module->globals.size());
       module->globals.reserve(imported_globals + globals_count);
       for (uint32_t i = 0; ok() && i < globals_count; ++i) {
@@ skipping 260 matching lines @@
     return consume_init_expr(nullptr, kWasmStmt);
   }
 
  private:
   Zone* module_zone;
   ModuleResult result_;
   ModuleOrigin origin_;
 
   uint32_t off(const byte* ptr) { return static_cast<uint32_t>(ptr - start_); }
 
+  void SetHasMemory(WasmModule* module) {
+    if (module->has_memory) {
+      error("At most one memory object is supported");
+    } else {
+      module->has_memory = true;
+    }
+  }
+
   // Decodes a single global entry inside a module starting at {pc_}.
   void DecodeGlobalInModule(WasmModule* module, uint32_t index,
                             WasmGlobal* global) {
     global->type = consume_value_type();
     global->mutability = consume_u8("mutability") != 0;
     const byte* pos = pc();
     global->init = consume_init_expr(module, kWasmStmt);
     switch (global->init.kind) {
       case WasmInitExpr::kGlobalIndex: {
         uint32_t other_index = global->init.val.global_index;
@@ skipping 534 matching lines @@
     table.push_back(std::move(func_asm_offsets));
   }
   if (decoder.more()) decoder.error("unexpected additional bytes");
 
   return decoder.toResult(std::move(table));
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8