diff --git a/src/asmjs/asm-js.cc b/src/asmjs/asm-js.cc index ce9f653ee3..2553ecb919 100644 --- a/src/asmjs/asm-js.cc +++ b/src/asmjs/asm-js.cc @@ -297,7 +297,7 @@ inline bool IsValidAsmjsMemorySize(size_t size) { // Enforce asm.js spec minimum size. if (size < (1u << 12u)) return false; // Enforce engine-limited and flag-limited maximum allocation size. - if (size > wasm::max_initial_mem_pages() * uint64_t{wasm::kWasmPageSize}) { + if (size > wasm::max_mem_pages() * uint64_t{wasm::kWasmPageSize}) { return false; } // Enforce power-of-2 sizes for 2^12 - 2^24. diff --git a/src/flags/flag-definitions.h b/src/flags/flag-definitions.h index d7fbd96fb9..06cc7a28b2 100644 --- a/src/flags/flag-definitions.h +++ b/src/flags/flag-definitions.h @@ -767,9 +767,7 @@ DEFINE_BOOL(wasm_async_compilation, true, DEFINE_BOOL(wasm_test_streaming, false, "use streaming compilation instead of async compilation for tests") DEFINE_UINT(wasm_max_mem_pages, v8::internal::wasm::kSpecMaxMemoryPages, - "maximum initial number of 64KiB memory pages of a wasm instance") -DEFINE_UINT(wasm_max_mem_pages_growth, v8::internal::wasm::kSpecMaxMemoryPages, - "maximum number of 64KiB pages a Wasm memory can grow to") + "maximum number of 64KiB memory pages per wasm memory") DEFINE_UINT(wasm_max_table_size, v8::internal::wasm::kV8MaxWasmTableSize, "maximum table size of a wasm instance") DEFINE_UINT(wasm_max_code_space, v8::internal::kMaxWasmCodeMB, diff --git a/src/objects/backing-store.cc b/src/objects/backing-store.cc index e81b854fce..c67fff0fa9 100644 --- a/src/objects/backing-store.cc +++ b/src/objects/backing-store.cc @@ -276,9 +276,9 @@ std::unique_ptr BackingStore::Allocate( } // Trying to allocate 4 GiB on a 32-bit platform is guaranteed to fail. -// We don't lower the official max_maximum_mem_pages() limit because that -// would be observable upon instantiation; this way the effective limit -// on 32-bit platforms is defined by the allocator. +// We don't lower the official max_mem_pages() limit because that would be +// observable upon instantiation; this way the effective limit on 32-bit +// platforms is defined by the allocator. constexpr size_t kPlatformMaxPages = std::numeric_limits::max() / wasm::kWasmPageSize; @@ -325,7 +325,7 @@ std::unique_ptr BackingStore::TryAllocateWasmMemory( // Compute size of reserved memory. - size_t engine_max_pages = wasm::max_maximum_mem_pages(); + size_t engine_max_pages = wasm::max_mem_pages(); maximum_pages = std::min(engine_max_pages, maximum_pages); // If the platform doesn't support so many pages, attempting to allocate // is guaranteed to fail, so we don't even try. diff --git a/src/wasm/c-api.cc b/src/wasm/c-api.cc index fccab22d10..0bb6552943 100644 --- a/src/wasm/c-api.cc +++ b/src/wasm/c-api.cc @@ -1902,8 +1902,8 @@ auto Memory::make(Store* store_abs, const MemoryType* type) -> own { const Limits& limits = type->limits(); uint32_t minimum = limits.min; - // The max_initial_mem_pages limit is only spec'ed for JS embeddings, - // so we'll directly use the maximum pages limit here. + // The max_mem_pages limit is only spec'ed for JS embeddings, so we'll + // directly use the maximum pages limit here. if (minimum > i::wasm::kSpecMaxMemoryPages) return nullptr; uint32_t maximum = limits.max; if (maximum != Limits(0).max) { diff --git a/src/wasm/compilation-environment.h b/src/wasm/compilation-environment.h index e7236634ee..2def2b65ac 100644 --- a/src/wasm/compilation-environment.h +++ b/src/wasm/compilation-environment.h @@ -75,7 +75,7 @@ struct CompilationEnv { : 0), max_memory_size((module && module->has_maximum_pages ? module->maximum_pages - : max_initial_mem_pages()) * + : max_mem_pages()) * uint64_t{kWasmPageSize}), enabled_features(enabled_features), lower_simd(lower_simd) {} diff --git a/src/wasm/module-decoder.cc b/src/wasm/module-decoder.cc index 9619779bf7..90000aa31d 100644 --- a/src/wasm/module-decoder.cc +++ b/src/wasm/module-decoder.cc @@ -636,10 +636,10 @@ class ModuleDecoderImpl : public Decoder { // ===== Imported memory ============================================= if (!AddMemory(module_.get())) break; uint8_t flags = validate_memory_flags(&module_->has_shared_memory); - consume_resizable_limits( - "memory", "pages", max_initial_mem_pages(), - &module_->initial_pages, &module_->has_maximum_pages, - max_maximum_mem_pages(), &module_->maximum_pages, flags); + consume_resizable_limits("memory", "pages", max_mem_pages(), + &module_->initial_pages, + &module_->has_maximum_pages, max_mem_pages(), + &module_->maximum_pages, flags); break; } case kExternalGlobal: { @@ -736,10 +736,10 @@ class ModuleDecoderImpl : public Decoder { for (uint32_t i = 0; ok() && i < memory_count; i++) { if (!AddMemory(module_.get())) break; uint8_t flags = validate_memory_flags(&module_->has_shared_memory); - consume_resizable_limits( - "memory", "pages", max_initial_mem_pages(), &module_->initial_pages, - &module_->has_maximum_pages, max_maximum_mem_pages(), - &module_->maximum_pages, flags); + consume_resizable_limits("memory", "pages", max_mem_pages(), + &module_->initial_pages, + &module_->has_maximum_pages, max_mem_pages(), + &module_->maximum_pages, flags); } } diff --git a/src/wasm/module-instantiate.cc b/src/wasm/module-instantiate.cc index 8bf29cb3fd..c37d02b220 100644 --- a/src/wasm/module-instantiate.cc +++ b/src/wasm/module-instantiate.cc @@ -1675,10 +1675,9 @@ void InstanceBuilder::InitGlobals(Handle instance) { // Allocate memory for a module instance as a new JSArrayBuffer. bool InstanceBuilder::AllocateMemory() { uint32_t initial_pages = module_->initial_pages; - uint32_t maximum_pages = module_->has_maximum_pages - ? module_->maximum_pages - : wasm::max_maximum_mem_pages(); - if (initial_pages > max_initial_mem_pages()) { + uint32_t maximum_pages = + module_->has_maximum_pages ? module_->maximum_pages : max_mem_pages(); + if (initial_pages > max_mem_pages()) { thrower_->RangeError("Out of memory: wasm memory too large"); return false; } diff --git a/src/wasm/wasm-engine.cc b/src/wasm/wasm-engine.cc index fcdbdd4a2c..61d01daa77 100644 --- a/src/wasm/wasm-engine.cc +++ b/src/wasm/wasm-engine.cc @@ -1444,18 +1444,12 @@ std::shared_ptr WasmEngine::GetWasmEngine() { return *GetSharedWasmEngine(); } -// {max_initial_mem_pages} is declared in wasm-limits.h. -uint32_t max_initial_mem_pages() { +// {max_mem_pages} is declared in wasm-limits.h. +uint32_t max_mem_pages() { STATIC_ASSERT(kV8MaxWasmMemoryPages <= kMaxUInt32); return std::min(uint32_t{kV8MaxWasmMemoryPages}, FLAG_wasm_max_mem_pages); } -uint32_t max_maximum_mem_pages() { - STATIC_ASSERT(kV8MaxWasmMemoryPages <= kMaxUInt32); - return std::min(uint32_t{kV8MaxWasmMemoryPages}, - FLAG_wasm_max_mem_pages_growth); -} - // {max_table_init_entries} is declared in wasm-limits.h. uint32_t max_table_init_entries() { return std::min(uint32_t{kV8MaxWasmTableInitEntries}, diff --git a/src/wasm/wasm-js.cc b/src/wasm/wasm-js.cc index 62632b0d4a..16f4c5d3f9 100644 --- a/src/wasm/wasm-js.cc +++ b/src/wasm/wasm-js.cc @@ -1134,15 +1134,14 @@ void WebAssemblyMemory(const v8::FunctionCallbackInfo& args) { int64_t initial = 0; if (!GetInitialOrMinimumProperty(isolate, &thrower, context, descriptor, - &initial, 0, - i::wasm::max_initial_mem_pages())) { + &initial, 0, i::wasm::max_mem_pages())) { return; } // The descriptor's 'maximum'. int64_t maximum = -1; if (!GetOptionalIntegerProperty(isolate, &thrower, context, descriptor, v8_str(isolate, "maximum"), nullptr, &maximum, - initial, i::wasm::max_maximum_mem_pages())) { + initial, i::wasm::max_mem_pages())) { return; } @@ -1730,8 +1729,8 @@ void WebAssemblyMemoryGrow(const v8::FunctionCallbackInfo& args) { } uint64_t max_size64 = receiver->maximum_pages(); - if (max_size64 > uint64_t{i::wasm::max_maximum_mem_pages()}) { - max_size64 = i::wasm::max_maximum_mem_pages(); + if (max_size64 > uint64_t{i::wasm::max_mem_pages()}) { + max_size64 = i::wasm::max_mem_pages(); } i::Handle old_buffer(receiver->array_buffer(), i_isolate); diff --git a/src/wasm/wasm-limits.h b/src/wasm/wasm-limits.h index 6cae6e1410..e525c7f07d 100644 --- a/src/wasm/wasm-limits.h +++ b/src/wasm/wasm-limits.h @@ -31,8 +31,8 @@ constexpr size_t kV8MaxWasmExceptions = 1000000; constexpr size_t kV8MaxWasmExceptionTypes = 1000000; constexpr size_t kV8MaxWasmDataSegments = 100000; // This indicates the maximum memory size our implementation supports. -// Don't use this limit directly; use {max_initial_mem_pages()} instead -// to take the spec'ed limit as well as command line flag into account. +// Don't use this limit directly; use {max_mem_pages()} instead to take the +// spec'ed limit as well as command line flag into account. constexpr size_t kV8MaxWasmMemoryPages = 65536; // = 4 GiB constexpr size_t kV8MaxWasmStringSize = 100000; constexpr size_t kV8MaxWasmModuleSize = 1024 * 1024 * 1024; // = 1 GiB @@ -65,13 +65,12 @@ constexpr uint64_t kWasmMaxHeapOffset = // Defined in wasm-engine.cc. // TODO(wasm): Make this size_t for wasm64. Currently the --wasm-max-mem-pages // flag is only uint32_t. -V8_EXPORT_PRIVATE uint32_t max_initial_mem_pages(); -V8_EXPORT_PRIVATE uint32_t max_maximum_mem_pages(); +V8_EXPORT_PRIVATE uint32_t max_mem_pages(); uint32_t max_table_init_entries(); size_t max_module_size(); inline uint64_t max_mem_bytes() { - return uint64_t{max_maximum_mem_pages()} * kWasmPageSize; + return uint64_t{max_mem_pages()} * kWasmPageSize; } } // namespace wasm diff --git a/src/wasm/wasm-objects.cc b/src/wasm/wasm-objects.cc index e0202b98d1..0abc4ec077 100644 --- a/src/wasm/wasm-objects.cc +++ b/src/wasm/wasm-objects.cc @@ -914,16 +914,15 @@ int32_t WasmMemoryObject::Grow(Isolate* isolate, if (old_buffer->is_asmjs_memory()) return -1; // Checks for maximum memory size. - uint32_t maximum_pages = wasm::max_maximum_mem_pages(); + uint32_t maximum_pages = wasm::max_mem_pages(); if (memory_object->has_maximum_pages()) { maximum_pages = std::min( maximum_pages, static_cast(memory_object->maximum_pages())); } - DCHECK_GE(wasm::max_maximum_mem_pages(), maximum_pages); size_t old_size = old_buffer->byte_length(); DCHECK_EQ(0, old_size % wasm::kWasmPageSize); size_t old_pages = old_size / wasm::kWasmPageSize; - CHECK_GE(wasm::max_maximum_mem_pages(), old_pages); + CHECK_GE(wasm::max_mem_pages(), old_pages); if (pages > maximum_pages - old_pages) return -1; std::shared_ptr backing_store = old_buffer->GetBackingStore(); if (!backing_store) return -1; diff --git a/test/fuzzer/wasm.cc b/test/fuzzer/wasm.cc index 1230a7d46d..aaa958c4d5 100644 --- a/test/fuzzer/wasm.cc +++ b/test/fuzzer/wasm.cc @@ -32,8 +32,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { // We reduce the maximum memory size and table size of WebAssembly instances // to avoid OOMs in the fuzzer. i::FlagScope max_mem_flag_scope(&i::FLAG_wasm_max_mem_pages, 32); - i::FlagScope max_mem_growth_flag_scope( - &i::FLAG_wasm_max_mem_pages_growth, 32); i::FlagScope max_table_size_scope(&i::FLAG_wasm_max_table_size, 100); v8_fuzzer::FuzzerSupport* support = v8_fuzzer::FuzzerSupport::Get();