diff --git a/common.gypi b/common.gypi index 5752c17168d50a..aaae133e1ac188 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.20', + 'v8_embedder_string': '-node.21', # Enable disassembler for `--print-code` v8 options 'v8_enable_disassembler': 1, diff --git a/deps/v8/src/api.cc b/deps/v8/src/api.cc index bd4a0fde702a7b..5c559ceb8adbc1 100644 --- a/deps/v8/src/api.cc +++ b/deps/v8/src/api.cc @@ -889,8 +889,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) { @@ -905,7 +904,9 @@ 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 = + static_cast( + static_cast(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 bcb5a2c982b5a7..a2f8fb5a4a0bed 100644 --- a/deps/v8/src/flag-definitions.h +++ b/deps/v8/src/flag-definitions.h @@ -161,12 +161,14 @@ 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 NULL}, cmt) #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) @@ -553,18 +555,18 @@ DEFINE_BOOL(trace_opt_verbose, false, "extra verbose compilation tracing") DEFINE_IMPLICATION(trace_opt_verbose, trace_opt) // 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(gc_interval, -1, "garbage collect after allocations") DEFINE_INT(retain_maps_for_n_gc, 2, diff --git a/deps/v8/src/flags.cc b/deps/v8/src/flags.cc index 9fdc5d04be84dd..5a727514689c1a 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 @@ -40,6 +41,7 @@ struct Flag { TYPE_INT, TYPE_UINT, TYPE_FLOAT, + TYPE_SIZE_T, TYPE_STRING, TYPE_ARGS }; @@ -82,6 +84,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_); @@ -120,6 +127,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_); @@ -143,6 +155,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(); @@ -174,6 +188,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; @@ -202,6 +219,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"; } @@ -228,6 +247,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 : "NULL"); @@ -360,6 +382,27 @@ static Flag* FindFlag(const char* name) { return NULL; } +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, @@ -425,27 +468,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) : NULL, true); break; diff --git a/deps/v8/src/heap/heap.cc b/deps/v8/src/heap/heap.cc index b13ec784f56358..5120975cb12628 100644 --- a/deps/v8/src/heap/heap.cc +++ b/deps/v8/src/heap/heap.cc @@ -5463,8 +5463,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 7b877703855c88..f1e65b8a5f0968 100644 --- a/deps/v8/src/heap/heap.h +++ b/deps/v8/src/heap/heap.h @@ -584,15 +584,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; @@ -1293,10 +1293,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); } @@ -1308,11 +1308,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); }