From d0982e33af7cf2a031d2d3bc22fd48d0a29e0be4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Wed, 7 Mar 2018 12:37:54 +0100 Subject: [PATCH] deps: cherry-pick 46c4979 from upstream V8 Original commit message: Use wider types for max_old_space_size and co. Make --max_old_space_size and friends work with values >= 2**31. Such values did not work reliably (or sometimes not all) due to signed integer overflow in size computations, which is UB. Fixes https://github.com/nodejs/node/issues/18786. Bug: chromium:814138 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: Ibe23cef2417fd5b4a727022b8b0d4b50f1417182 Reviewed-on: https://chromium-review.googlesource.com/927063 Commit-Queue: Ben Noordhuis Reviewed-by: Michael Lippautz Cr-Commit-Position: refs/heads/master@{#51433} Refs: https://github.com/v8/v8/commit/46c4979e860a9aaf4444616955e896e70e72afbf PR-URL: https://github.com/nodejs/node/pull/18453 Reviewed-By: James M Snell Reviewed-By: Colin Ihrig Reviewed-By: Yang Guo Reviewed-By: Ali Ijaz Sheikh Reviewed-By: Michael Dawson --- common.gypi | 2 +- deps/v8/include/v8.h | 22 +++++------ deps/v8/src/api.cc | 5 +-- deps/v8/src/flag-definitions.h | 18 +++++---- deps/v8/src/flags.cc | 67 ++++++++++++++++++++++++++-------- deps/v8/src/heap/heap.cc | 4 +- deps/v8/src/heap/heap.h | 26 ++++++------- 7 files changed, 90 insertions(+), 54 deletions(-) diff --git a/common.gypi b/common.gypi index f6002f9349121c..a3aeff7e03d480 100644 --- a/common.gypi +++ b/common.gypi @@ -27,7 +27,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.3', + 'v8_embedder_string': '-node.4', # Enable disassembler for `--print-code` v8 options 'v8_enable_disassembler': 1, diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h index acb3efbc711d57..d5b554dc96622d 100644 --- a/deps/v8/include/v8.h +++ b/deps/v8/include/v8.h @@ -6030,13 +6030,13 @@ class V8_EXPORT ResourceConstraints { // Returns the max semi-space size in MB. V8_DEPRECATE_SOON("Use max_semi_space_size_in_kb()", - int max_semi_space_size()) { - return static_cast(max_semi_space_size_in_kb_ / 1024); + size_t max_semi_space_size()) { + return max_semi_space_size_in_kb_ / 1024; } // Sets the max semi-space size in MB. V8_DEPRECATE_SOON("Use set_max_semi_space_size_in_kb(size_t limit_in_kb)", - void set_max_semi_space_size(int limit_in_mb)) { + void set_max_semi_space_size(size_t limit_in_mb)) { max_semi_space_size_in_kb_ = limit_in_mb * 1024; } @@ -6050,16 +6050,16 @@ class V8_EXPORT ResourceConstraints { max_semi_space_size_in_kb_ = limit_in_kb; } - int max_old_space_size() const { return max_old_space_size_; } - void set_max_old_space_size(int limit_in_mb) { + size_t max_old_space_size() const { return max_old_space_size_; } + void set_max_old_space_size(size_t limit_in_mb) { max_old_space_size_ = limit_in_mb; } V8_DEPRECATE_SOON("max_executable_size_ is subsumed by max_old_space_size_", - int max_executable_size() const) { + size_t max_executable_size() const) { return max_executable_size_; } V8_DEPRECATE_SOON("max_executable_size_ is subsumed by max_old_space_size_", - void set_max_executable_size(int limit_in_mb)) { + void set_max_executable_size(size_t limit_in_mb)) { max_executable_size_ = limit_in_mb; } uint32_t* stack_limit() const { return stack_limit_; } @@ -6070,17 +6070,15 @@ class V8_EXPORT ResourceConstraints { code_range_size_ = limit_in_mb; } size_t max_zone_pool_size() const { return max_zone_pool_size_; } - void set_max_zone_pool_size(const size_t bytes) { - max_zone_pool_size_ = bytes; - } + void set_max_zone_pool_size(size_t bytes) { max_zone_pool_size_ = bytes; } private: // max_semi_space_size_ is in KB size_t max_semi_space_size_in_kb_; // The remaining limits are in MB - int max_old_space_size_; - int max_executable_size_; + size_t max_old_space_size_; + size_t max_executable_size_; uint32_t* stack_limit_; size_t code_range_size_; size_t max_zone_pool_size_; diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc index 147cc397f226d3..d258c878532c25 100644 --- a/deps/v8/src/api.cc +++ b/deps/v8/src/api.cc @@ -979,8 +979,7 @@ void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory, uint64_t virtual_memory_limit) { set_max_semi_space_size_in_kb( i::Heap::ComputeMaxSemiSpaceSize(physical_memory)); - set_max_old_space_size( - static_cast(i::Heap::ComputeMaxOldGenerationSize(physical_memory))); + set_max_old_space_size(i::Heap::ComputeMaxOldGenerationSize(physical_memory)); set_max_zone_pool_size(i::AccountingAllocator::kMaxPoolSize); if (virtual_memory_limit > 0 && i::kRequiresCodeRange) { @@ -995,7 +994,7 @@ void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory, void SetResourceConstraints(i::Isolate* isolate, const ResourceConstraints& constraints) { size_t semi_space_size = constraints.max_semi_space_size_in_kb(); - int old_space_size = constraints.max_old_space_size(); + size_t old_space_size = constraints.max_old_space_size(); size_t code_range_size = constraints.code_range_size(); size_t max_pool_size = constraints.max_zone_pool_size(); if (semi_space_size != 0 || old_space_size != 0 || code_range_size != 0) { diff --git a/deps/v8/src/flag-definitions.h b/deps/v8/src/flag-definitions.h index e40e182dad51e6..8c3a08f81abc10 100644 --- a/deps/v8/src/flag-definitions.h +++ b/deps/v8/src/flag-definitions.h @@ -161,6 +161,7 @@ struct MaybeBoolFlag { #define DEFINE_INT(nam, def, cmt) FLAG(INT, int, nam, def, cmt) #define DEFINE_UINT(nam, def, cmt) FLAG(UINT, unsigned int, nam, def, cmt) #define DEFINE_FLOAT(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt) +#define DEFINE_SIZE_T(nam, def, cmt) FLAG(SIZE_T, size_t, nam, def, cmt) #define DEFINE_STRING(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt) #define DEFINE_ARGS(nam, cmt) \ FLAG(ARGS, JSArguments, nam, {0 COMMA nullptr}, cmt) @@ -168,6 +169,7 @@ struct MaybeBoolFlag { #define DEFINE_ALIAS_BOOL(alias, nam) FLAG_ALIAS(BOOL, bool, alias, nam) #define DEFINE_ALIAS_INT(alias, nam) FLAG_ALIAS(INT, int, alias, nam) #define DEFINE_ALIAS_FLOAT(alias, nam) FLAG_ALIAS(FLOAT, double, alias, nam) +#define DEFINE_ALIAS_SIZE_T(alias, nam) FLAG_ALIAS(SIZE_T, size_t, alias, nam) #define DEFINE_ALIAS_STRING(alias, nam) \ FLAG_ALIAS(STRING, const char*, alias, nam) #define DEFINE_ALIAS_ARGS(alias, nam) FLAG_ALIAS(ARGS, JSArguments, alias, nam) @@ -596,18 +598,18 @@ DEFINE_INT(stress_sampling_allocation_profiler, 0, "Enables sampling allocation profiler with X as a sample interval") // Garbage collections flags. -DEFINE_INT(min_semi_space_size, 0, - "min size of a semi-space (in MBytes), the new space consists of two" - "semi-spaces") -DEFINE_INT(max_semi_space_size, 0, - "max size of a semi-space (in MBytes), the new space consists of two" - "semi-spaces") +DEFINE_SIZE_T(min_semi_space_size, 0, + "min size of a semi-space (in MBytes), the new space consists of " + "two semi-spaces") +DEFINE_SIZE_T(max_semi_space_size, 0, + "max size of a semi-space (in MBytes), the new space consists of " + "two semi-spaces") DEFINE_INT(semi_space_growth_factor, 2, "factor by which to grow the new space") DEFINE_BOOL(experimental_new_space_growth_heuristic, false, "Grow the new space based on the percentage of survivors instead " "of their absolute value.") -DEFINE_INT(max_old_space_size, 0, "max size of the old space (in Mbytes)") -DEFINE_INT(initial_old_space_size, 0, "initial old space size (in Mbytes)") +DEFINE_SIZE_T(max_old_space_size, 0, "max size of the old space (in Mbytes)") +DEFINE_SIZE_T(initial_old_space_size, 0, "initial old space size (in Mbytes)") DEFINE_BOOL(gc_global, false, "always perform global GCs") DEFINE_INT(random_gc_interval, 0, "Collect garbage after random(0, X) allocations. It overrides " diff --git a/deps/v8/src/flags.cc b/deps/v8/src/flags.cc index 693e514e94eca0..2a05ad3da8d70c 100644 --- a/deps/v8/src/flags.cc +++ b/deps/v8/src/flags.cc @@ -5,6 +5,7 @@ #include "src/flags.h" #include +#include #include #include @@ -39,6 +40,7 @@ struct Flag { TYPE_INT, TYPE_UINT, TYPE_FLOAT, + TYPE_SIZE_T, TYPE_STRING, TYPE_ARGS }; @@ -81,6 +83,11 @@ struct Flag { return reinterpret_cast(valptr_); } + size_t* size_t_variable() const { + DCHECK(type_ == TYPE_SIZE_T); + return reinterpret_cast(valptr_); + } + const char* string_value() const { DCHECK(type_ == TYPE_STRING); return *reinterpret_cast(valptr_); @@ -119,6 +126,11 @@ struct Flag { return *reinterpret_cast(defptr_); } + size_t size_t_default() const { + DCHECK(type_ == TYPE_SIZE_T); + return *reinterpret_cast(defptr_); + } + const char* string_default() const { DCHECK(type_ == TYPE_STRING); return *reinterpret_cast(defptr_); @@ -142,6 +154,8 @@ struct Flag { return *uint_variable() == uint_default(); case TYPE_FLOAT: return *float_variable() == float_default(); + case TYPE_SIZE_T: + return *size_t_variable() == size_t_default(); case TYPE_STRING: { const char* str1 = string_value(); const char* str2 = string_default(); @@ -173,6 +187,9 @@ struct Flag { case TYPE_FLOAT: *float_variable() = float_default(); break; + case TYPE_SIZE_T: + *size_t_variable() = size_t_default(); + break; case TYPE_STRING: set_string_value(string_default(), false); break; @@ -201,6 +218,8 @@ static const char* Type2String(Flag::FlagType type) { case Flag::TYPE_UINT: return "uint"; case Flag::TYPE_FLOAT: return "float"; + case Flag::TYPE_SIZE_T: + return "size_t"; case Flag::TYPE_STRING: return "string"; case Flag::TYPE_ARGS: return "arguments"; } @@ -227,6 +246,9 @@ std::ostream& operator<<(std::ostream& os, const Flag& flag) { // NOLINT case Flag::TYPE_FLOAT: os << *flag.float_variable(); break; + case Flag::TYPE_SIZE_T: + os << *flag.size_t_variable(); + break; case Flag::TYPE_STRING: { const char* str = flag.string_value(); os << (str ? str : "nullptr"); @@ -358,6 +380,27 @@ static Flag* FindFlag(const char* name) { return nullptr; } +template +bool TryParseUnsigned(Flag* flag, const char* arg, const char* value, + char** endp, T* out_val) { + // We do not use strtoul because it accepts negative numbers. + // Rejects values >= 2**63 when T is 64 bits wide but that + // seems like an acceptable trade-off. + uint64_t max = static_cast(std::numeric_limits::max()); + errno = 0; + int64_t val = static_cast(strtoll(value, endp, 10)); + if (val < 0 || static_cast(val) > max || errno != 0) { + PrintF(stderr, + "Error: Value for flag %s of type %s is out of bounds " + "[0-%" PRIu64 + "]\n" + "Try --help for options\n", + arg, Type2String(flag->type()), max); + return false; + } + *out_val = static_cast(val); + return true; +} // static int FlagList::SetFlagsFromCommandLine(int* argc, @@ -422,27 +465,21 @@ int FlagList::SetFlagsFromCommandLine(int* argc, case Flag::TYPE_INT: *flag->int_variable() = static_cast(strtol(value, &endp, 10)); break; - case Flag::TYPE_UINT: { - // We do not use strtoul because it accepts negative numbers. - int64_t val = static_cast(strtoll(value, &endp, 10)); - if (val < 0 || val > std::numeric_limits::max()) { - PrintF(stderr, - "Error: Value for flag %s of type %s is out of bounds " - "[0-%" PRIu64 - "]\n" - "Try --help for options\n", - arg, Type2String(flag->type()), - static_cast( - std::numeric_limits::max())); + case Flag::TYPE_UINT: + if (!TryParseUnsigned(flag, arg, value, &endp, + flag->uint_variable())) { return_code = j; - break; } - *flag->uint_variable() = static_cast(val); break; - } case Flag::TYPE_FLOAT: *flag->float_variable() = strtod(value, &endp); break; + case Flag::TYPE_SIZE_T: + if (!TryParseUnsigned(flag, arg, value, &endp, + flag->size_t_variable())) { + return_code = j; + } + break; case Flag::TYPE_STRING: flag->set_string_value(value ? StrDup(value) : nullptr, true); break; diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc index 49c2eccb2df39f..7f965602b8a325 100644 --- a/deps/v8/src/heap/heap.cc +++ b/deps/v8/src/heap/heap.cc @@ -5078,8 +5078,8 @@ bool Heap::ConfigureHeap(size_t max_semi_space_size_in_kb, // The new space size must be a power of two to support single-bit testing // for containment. - max_semi_space_size_ = base::bits::RoundUpToPowerOfTwo32( - static_cast(max_semi_space_size_)); + max_semi_space_size_ = static_cast(base::bits::RoundUpToPowerOfTwo64( + static_cast(max_semi_space_size_))); if (max_semi_space_size_ == kMaxSemiSpaceSizeInKB * KB) { // Start with at least 1*MB semi-space on machines with a lot of memory. diff --git a/deps/v8/src/heap/heap.h b/deps/v8/src/heap/heap.h index 3d8234f392a49e..7cc65479cabcf6 100644 --- a/deps/v8/src/heap/heap.h +++ b/deps/v8/src/heap/heap.h @@ -603,15 +603,15 @@ class Heap { #endif // Semi-space size needs to be a multiple of page size. - static const int kMinSemiSpaceSizeInKB = + static const size_t kMinSemiSpaceSizeInKB = 1 * kPointerMultiplier * ((1 << kPageSizeBits) / KB); - static const int kMaxSemiSpaceSizeInKB = + static const size_t kMaxSemiSpaceSizeInKB = 16 * kPointerMultiplier * ((1 << kPageSizeBits) / KB); // The old space size has to be a multiple of Page::kPageSize. // Sizes are in MB. - static const int kMinOldGenerationSize = 128 * kPointerMultiplier; - static const int kMaxOldGenerationSize = 1024 * kPointerMultiplier; + static const size_t kMinOldGenerationSize = 128 * kPointerMultiplier; + static const size_t kMaxOldGenerationSize = 1024 * kPointerMultiplier; static const int kTraceRingBufferSize = 512; static const int kStacktraceBufferSize = 512; @@ -1360,10 +1360,10 @@ class Heap { size_t MaxOldGenerationSize() { return max_old_generation_size_; } static size_t ComputeMaxOldGenerationSize(uint64_t physical_memory) { - const int old_space_physical_memory_factor = 4; - int computed_size = - static_cast(physical_memory / i::MB / - old_space_physical_memory_factor * kPointerMultiplier); + const size_t old_space_physical_memory_factor = 4; + size_t computed_size = static_cast( + physical_memory / i::MB / old_space_physical_memory_factor * + kPointerMultiplier); return Max(Min(computed_size, kMaxOldGenerationSize), kMinOldGenerationSize); } @@ -1375,11 +1375,11 @@ class Heap { uint64_t capped_physical_memory = Max(Min(physical_memory, max_physical_memory), min_physical_memory); // linearly scale max semi-space size: (X-A)/(B-A)*(D-C)+C - int semi_space_size_in_kb = - static_cast(((capped_physical_memory - min_physical_memory) * - (kMaxSemiSpaceSizeInKB - kMinSemiSpaceSizeInKB)) / - (max_physical_memory - min_physical_memory) + - kMinSemiSpaceSizeInKB); + size_t semi_space_size_in_kb = + static_cast(((capped_physical_memory - min_physical_memory) * + (kMaxSemiSpaceSizeInKB - kMinSemiSpaceSizeInKB)) / + (max_physical_memory - min_physical_memory) + + kMinSemiSpaceSizeInKB); return RoundUp(semi_space_size_in_kb, (1 << kPageSizeBits) / KB); }