From a57560855506e5a12d39d0b4d48c997bb29538d0 Mon Sep 17 00:00:00 2001 From: Francis McCabe Date: Mon, 17 Aug 2020 19:33:57 +0000 Subject: [PATCH] Revert "Reland^3 "[flags] warn about contradictory flags"" This reverts commit dc18b82221da49b59c486c9eed692e5bf6fc7aea. Reason for revert: still causing failures: https://ci.chromium.org/p/v8/builders/ci/V8%20Linux%20-%20debug/31566 Original change's description: > Reland^3 "[flags] warn about contradictory flags" > > This is a reland of 0ba115e6a9ef0a8aa2af9ce22a1a4521a4a0b363 > Changes: > - Also allow second parameter influenced by --cache to be reassigned. > - Fix --stress-opt to only --always-opt in the last iteration as before. > > Original change's description: > > Reland^2 "[flags] warn about contradictory flags" > > > > This is a reland of d8f8a7e2105305921ca31450ecc38e009bc075c3 > > Change compared to last reland: > > - Do not check for d8 flag contradictions in the presence of --fuzzing > > - Allow identical re-declaration of --cache=* > > > > Original change's description: > > > Reland "[flags] warn about contradictory flags" > > > > > > This is a reland of b8f91666649b637e87a338f884d7987b169f6692 > > > Difference to previous CL: Additional functionality to specify > > > incompatible flags based on GN variables and extra-flags, used > > > to fix the issues that came up on the waterfall. > > > > > > This also changes the rules regarding repeated flags: While > > > explicitly repeated flags are allowed for boolean values as long > > > as they are identical, repeated flags or explicit flags in the > > > presence of an active implication are disallowed for non-boolean > > > flags. The latter simplifies specifying conflict rules in > > > variants.py. Otherwise a rule like > > > > > > INCOMPATIBLE_FLAGS_PER_EXTRA_FLAG = { > > > "--gc-interval=*": ["--gc-interval=*"], > > > } > > > > > > wouldn't work because specifying the same GC interval twice > > > wouldn't actually count as a conflict. This was an issue with > > > test/mjsunit/wasm/gc-buffer.js, which specifies > > > --gc-interval=500 exactly like the extra flag by the stress bot. > > > > > > Also, this now expands contradictory flags checking to d8 flags > > > for consistency. > > > > > > Original change's description: > > > > [flags] warn about contradictory flags > > > > > > > > Design Doc: https://docs.google.com/document/d/1lkvu8crkK7Ei39qjkPCFijpNyxWXsOktG9GB-7K34jM/ > > > > > > > > Bug: v8:10577 > > > > Change-Id: Ib9cfdffa401c48c895bf31caed5ee03545beddab > > > > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2154792 > > > > Reviewed-by: Clemens Backes > > > > Reviewed-by: Michael Achenbach > > > > Reviewed-by: Georg Neis > > > > Reviewed-by: Tamer Tas > > > > Commit-Queue: Tobias Tebbi > > > > Cr-Commit-Position: refs/heads/master@{#68168} > > > > > > Bug: v8:10577 > > > Change-Id: I268e590ee18a535b13dee14eeb15ddd0a9ee8341 > > > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2235115 > > > Commit-Queue: Tobias Tebbi > > > Reviewed-by: Tamer Tas > > > Reviewed-by: Clemens Backes > > > Reviewed-by: Georg Neis > > > Cr-Commit-Position: refs/heads/master@{#68989} > > > > Bug: v8:10577 > > Change-Id: I31d2794d4f9ff630f3444210100c64d67d881276 > > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339464 > > Commit-Queue: Tobias Tebbi > > Reviewed-by: Clemens Backes > > Cr-Commit-Position: refs/heads/master@{#69339} > > Bug: v8:10577 > Cq-Include-Trybots: luci.v8.try:v8_linux64_tsan_rel_ng > Cq-Include-Trybots: luci.v8.try:v8_linux64_tsan_isolates_rel_ng > Change-Id: I4a69dc57a102782cb453144323e3752ac8278624 > Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2352770 > Commit-Queue: Tobias Tebbi > Reviewed-by: Tobias Tebbi > Reviewed-by: Clemens Backes > Cr-Commit-Position: refs/heads/master@{#69433} TBR=machenbach@chromium.org,neis@chromium.org,clemensb@chromium.org,tebbi@chromium.org,tmrts@chromium.org Change-Id: I4ccdd7b931d0ddccbcec1d6cfae8d4874ee49cfc No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: v8:10577 Cq-Include-Trybots: luci.v8.try:v8_linux64_tsan_rel_ng Cq-Include-Trybots: luci.v8.try:v8_linux64_tsan_isolates_rel_ng Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2360414 Reviewed-by: Francis McCabe Commit-Queue: Francis McCabe Cr-Commit-Position: refs/heads/master@{#69438} --- src/d8/d8-posix.cc | 10 +- src/d8/d8.cc | 33 +- src/d8/d8.h | 128 +++---- src/flags/flag-definitions.h | 79 ++--- src/flags/flags.cc | 338 +++++-------------- test/inspector/inspector-test.cc | 1 - test/inspector/inspector.status | 5 - test/message/wasm-trace-memory-liftoff.js | 2 +- test/message/wasm-trace-memory.js | 2 +- test/mjsunit/ensure-growing-store-learns.js | 11 +- test/mjsunit/mjsunit.status | 15 + test/mjsunit/random-bit-correlations.js | 10 +- test/mjsunit/regress/regress-356053.js | 2 +- test/mjsunit/regress/regress-411210.js | 2 +- test/mjsunit/regress/regress-487981.js | 2 +- test/mjsunit/regress/regress-8265.js | 2 + test/mjsunit/regress/regress-863810.js | 2 +- test/mjsunit/regress/regress-883059.js | 2 +- test/mjsunit/regress/regress-crbug-664506.js | 2 +- test/mjsunit/regress/wasm/regress-02256.js | 2 +- test/mjsunit/regress/wasm/regress-02256b.js | 5 +- test/mjsunit/regress/wasm/regress-02862.js | 2 +- test/mjsunit/regress/wasm/regress-666741.js | 2 +- test/mjsunit/string-case.js | 3 +- test/mjsunit/wasm/tier-up-testing-flag.js | 2 +- tools/testrunner/local/statusfile.py | 1 - tools/testrunner/local/variants.py | 48 +-- tools/testrunner/objects/testcase.py | 48 +-- 28 files changed, 199 insertions(+), 562 deletions(-) diff --git a/src/d8/d8-posix.cc b/src/d8/d8-posix.cc index c7313b4435..ba6356e447 100644 --- a/src/d8/d8-posix.cc +++ b/src/d8/d8-posix.cc @@ -677,7 +677,7 @@ char* Shell::ReadCharsFromTcpPort(const char* name, int* size_out) { if (connect(sockfd, reinterpret_cast(&serv_addr), sizeof(serv_addr)) < 0) { fprintf(stderr, "Failed to connect to localhost:%d\n", - Shell::options.read_from_tcp_port.get()); + Shell::options.read_from_tcp_port); close(sockfd); return nullptr; } @@ -705,7 +705,7 @@ char* Shell::ReadCharsFromTcpPort(const char* name, int* size_out) { ssize_t sent_now = send(sockfd, name + sent_len, name_len - sent_len, 0); if (sent_now < 0) { fprintf(stderr, "Failed to send %s to localhost:%d\n", name, - Shell::options.read_from_tcp_port.get()); + Shell::options.read_from_tcp_port); close(sockfd); return nullptr; } @@ -722,7 +722,7 @@ char* Shell::ReadCharsFromTcpPort(const char* name, int* size_out) { // We need those 4 bytes to read off the file length. if (received < 4) { fprintf(stderr, "Failed to receive %s's length from localhost:%d\n", name, - Shell::options.read_from_tcp_port.get()); + Shell::options.read_from_tcp_port); close(sockfd); return nullptr; } @@ -731,7 +731,7 @@ char* Shell::ReadCharsFromTcpPort(const char* name, int* size_out) { if (file_length < 0) { fprintf(stderr, "Received length %d for %s from localhost:%d\n", - file_length, name, Shell::options.read_from_tcp_port.get()); + file_length, name, Shell::options.read_from_tcp_port); close(sockfd); return nullptr; } @@ -746,7 +746,7 @@ char* Shell::ReadCharsFromTcpPort(const char* name, int* size_out) { recv(sockfd, chars + total_received, file_length - total_received, 0); if (received < 0) { fprintf(stderr, "Failed to receive %s from localhost:%d\n", name, - Shell::options.read_from_tcp_port.get()); + Shell::options.read_from_tcp_port); close(sockfd); delete[] chars; return nullptr; diff --git a/src/d8/d8.cc b/src/d8/d8.cc index f9a830fa23..26ccb62c68 100644 --- a/src/d8/d8.cc +++ b/src/d8/d8.cc @@ -472,7 +472,6 @@ std::atomic Shell::unhandled_promise_rejections_{0}; Global Shell::evaluation_context_; ArrayBuffer::Allocator* Shell::array_buffer_allocator; -bool check_d8_flag_contradictions = true; ShellOptions Shell::options; base::OnceType Shell::quit_once_ = V8_ONCE_INIT; @@ -3234,7 +3233,6 @@ void Worker::PostMessageOut(const v8::FunctionCallbackInfo& args) { bool Shell::SetOptions(int argc, char* argv[]) { bool logfile_per_isolate = false; - bool no_always_opt = false; for (int i = 0; i < argc; i++) { if (strcmp(argv[i], "--") == 0) { argv[i] = nullptr; @@ -3262,9 +3260,8 @@ bool Shell::SetOptions(int argc, char* argv[]) { argv[i] = nullptr; } else if (strcmp(argv[i], "--noalways-opt") == 0 || strcmp(argv[i], "--no-always-opt") == 0) { - no_always_opt = true; - } else if (strcmp(argv[i], "--fuzzing") == 0) { - check_d8_flag_contradictions = false; + // No support for stressing if we can't use --always-opt. + options.stress_opt = false; } else if (strcmp(argv[i], "--logfile-per-isolate") == 0) { logfile_per_isolate = true; argv[i] = nullptr; @@ -3405,10 +3402,6 @@ bool Shell::SetOptions(int argc, char* argv[]) { } } - if (options.stress_opt && no_always_opt) { - FATAL("Flag --no-always-opt is incompatible with --stress-opt."); - } - const char* usage = "Synopsis:\n" " shell [options] [--shell] [...]\n" @@ -3417,7 +3410,6 @@ bool Shell::SetOptions(int argc, char* argv[]) { " --shell run an interactive JavaScript shell\n" " --module execute a file as a JavaScript module\n\n"; using HelpOptions = i::FlagList::HelpOptions; - i::FLAG_abort_on_contradictory_flags = true; i::FlagList::SetFlagsFromCommandLine(&argc, argv, true, HelpOptions(HelpOptions::kExit, usage)); options.mock_arraybuffer_allocator = i::FLAG_mock_arraybuffer_allocator; @@ -3878,11 +3870,12 @@ class D8Testing { "--max-inlined-bytecode-size=999999 " "--max-inlined-bytecode-size-cumulative=999999 " "--noalways-opt"; + static const char* kForcedOptimizations = "--always-opt"; - if (run == 0) { + if (run == GetStressRuns() - 1) { + V8::SetFlagsFromString(kForcedOptimizations); + } else { V8::SetFlagsFromString(kLazyOptimizations); - } else if (run == GetStressRuns() - 1) { - i::FLAG_always_opt = true; } } @@ -4124,7 +4117,7 @@ int Shell::Main(int argc, char* argv[]) { options.stress_runs = D8Testing::GetStressRuns(); for (int i = 0; i < options.stress_runs && result == 0; i++) { printf("============ Stress %d/%d ============\n", i + 1, - options.stress_runs.get()); + options.stress_runs); D8Testing::PrepareStressRun(i); bool last_run = i == options.stress_runs - 1; result = RunMain(isolate, last_run); @@ -4135,7 +4128,7 @@ int Shell::Main(int argc, char* argv[]) { options.stress_runs = i::FLAG_stress_runs; for (int i = 0; i < options.stress_runs && result == 0; i++) { printf("============ Run %d/%d ============\n", i + 1, - options.stress_runs.get()); + options.stress_runs); bool last_run = i == options.stress_runs - 1; result = RunMain(isolate, last_run); } @@ -4162,16 +4155,14 @@ int Shell::Main(int argc, char* argv[]) { DCHECK(options.compile_options == v8::ScriptCompiler::kEagerCompile || options.compile_options == v8::ScriptCompiler::kNoCompileOptions); - options.compile_options.Overwrite( - v8::ScriptCompiler::kConsumeCodeCache); - options.code_cache_options.Overwrite( - ShellOptions::CodeCacheOptions::kNoProduceCache); + options.compile_options = v8::ScriptCompiler::kConsumeCodeCache; + options.code_cache_options = + ShellOptions::CodeCacheOptions::kNoProduceCache; printf("============ Run: Consume code cache ============\n"); // Second run to consume the cache in current isolate result = RunMain(isolate, true); - options.compile_options.Overwrite( - v8::ScriptCompiler::kNoCompileOptions); + options.compile_options = v8::ScriptCompiler::kNoCompileOptions; } else { bool last_run = true; result = RunMain(isolate, last_run); diff --git a/src/d8/d8.h b/src/d8/d8.h index c5b746e008..6b2c08fd6e 100644 --- a/src/d8/d8.h +++ b/src/d8/d8.h @@ -282,8 +282,6 @@ class PerIsolateData { int RealmFind(Local context); }; -extern bool check_d8_flag_contradictions; - class ShellOptions { public: enum CodeCacheOptions { @@ -294,97 +292,47 @@ class ShellOptions { ~ShellOptions() { delete[] isolate_sources; } - // In analogy to Flag::CheckFlagChange() in src/flags/flag.cc, only allow - // repeated flags for identical boolean values. We allow exceptions for flags - // with enum-like arguments since their conflicts can also be specified - // completely. - template ::value> - class DisallowReassignment { - public: - DisallowReassignment(const char* name, T value) - : name_(name), value_(value) {} - - operator T() const { return value_; } // NOLINT - T get() const { return value_; } - DisallowReassignment& operator=(T value) { - if (check_d8_flag_contradictions) { - if (kAllowIdenticalAssignment) { - if (specified_ && value_ != value) { - FATAL("Contradictory values for d8 flag --%s", name_); - } - } else { - if (specified_) { - FATAL("Repeated specification of d8 flag --%s", name_); - } - } - } - value_ = value; - specified_ = true; - return *this; - } - void Overwrite(T value) { value_ = value; } - - private: - const char* name_; - T value_; - bool specified_ = false; - }; - - DisallowReassignment fuzzilli_coverage_statistics = { - "fuzzilli-coverage-statistics", false}; - DisallowReassignment fuzzilli_enable_builtins_coverage = { - "fuzzilli-enable-builtins-coverage", true}; - DisallowReassignment send_idle_notification = {"send-idle-notification", - false}; - DisallowReassignment invoke_weak_callbacks = {"invoke-weak-callbacks", - false}; - DisallowReassignment omit_quit = {"omit-quit", false}; - DisallowReassignment wait_for_background_tasks = { - "wait-for-background-tasks", true}; - DisallowReassignment stress_opt = {"stress-opt", false}; - DisallowReassignment stress_runs = {"stress-runs", 1}; - DisallowReassignment stress_snapshot = {"stress-snapshot", false}; - DisallowReassignment interactive_shell = {"shell", false}; + bool fuzzilli_coverage_statistics = false; + bool fuzzilli_enable_builtins_coverage = true; + bool send_idle_notification = false; + bool invoke_weak_callbacks = false; + bool omit_quit = false; + bool wait_for_background_tasks = true; + bool stress_opt = false; + int stress_runs = 1; + bool stress_snapshot = false; + bool interactive_shell = false; bool test_shell = false; - DisallowReassignment expected_to_throw = {"throws", false}; - DisallowReassignment ignore_unhandled_promises = { - "ignore-unhandled-promises", false}; - DisallowReassignment mock_arraybuffer_allocator = { - "mock-arraybuffer-allocator", false}; - DisallowReassignment mock_arraybuffer_allocator_limit = { - "mock-arraybuffer-allocator-limit", 0}; - DisallowReassignment multi_mapped_mock_allocator = { - "multi-mapped-mock-allocator", false}; - DisallowReassignment enable_inspector = {"enable-inspector", false}; + bool expected_to_throw = false; + bool ignore_unhandled_promises = false; + bool mock_arraybuffer_allocator = false; + size_t mock_arraybuffer_allocator_limit = 0; + bool multi_mapped_mock_allocator = false; + bool enable_inspector = false; int num_isolates = 1; - DisallowReassignment - compile_options = {"cache", v8::ScriptCompiler::kNoCompileOptions}; - DisallowReassignment code_cache_options = { - "cache", CodeCacheOptions::kNoProduceCache}; - DisallowReassignment streaming_compile = {"streaming-compile", false}; - DisallowReassignment isolate_sources = {"isolate-sources", - nullptr}; - DisallowReassignment icu_data_file = {"icu-data-file", nullptr}; - DisallowReassignment icu_locale = {"icu-locale", nullptr}; - DisallowReassignment snapshot_blob = {"snapshot_blob", nullptr}; - DisallowReassignment trace_enabled = {"trace-enabled", false}; - DisallowReassignment trace_path = {"trace-path", nullptr}; - DisallowReassignment trace_config = {"trace-config", nullptr}; - DisallowReassignment lcov_file = {"lcov", nullptr}; - DisallowReassignment disable_in_process_stack_traces = { - "disable-in-process-stack-traces", false}; - DisallowReassignment read_from_tcp_port = {"read-from-tcp-port", -1}; - DisallowReassignment enable_os_system = {"enable-os-system", false}; - DisallowReassignment quiet_load = {"quiet-load", false}; - DisallowReassignment thread_pool_size = {"thread-pool-size", 0}; - DisallowReassignment stress_delay_tasks = {"stress-delay-tasks", false}; + v8::ScriptCompiler::CompileOptions compile_options = + v8::ScriptCompiler::kNoCompileOptions; + CodeCacheOptions code_cache_options = CodeCacheOptions::kNoProduceCache; + bool streaming_compile = false; + SourceGroup* isolate_sources = nullptr; + const char* icu_data_file = nullptr; + const char* icu_locale = nullptr; + const char* snapshot_blob = nullptr; + bool trace_enabled = false; + const char* trace_path = nullptr; + const char* trace_config = nullptr; + const char* lcov_file = nullptr; + bool disable_in_process_stack_traces = false; + int read_from_tcp_port = -1; + bool enable_os_system = false; + bool quiet_load = false; + int thread_pool_size = 0; + bool stress_delay_tasks = false; std::vector arguments; - DisallowReassignment include_arguments = {"arguments", true}; - DisallowReassignment cpu_profiler = {"cpu-profiler", false}; - DisallowReassignment cpu_profiler_print = {"cpu-profiler-print", false}; - DisallowReassignment fuzzy_module_file_extensions = { - "fuzzy-module-file-extensions", true}; + bool include_arguments = true; + bool cpu_profiler = false; + bool cpu_profiler_print = false; + bool fuzzy_module_file_extensions = true; }; class Shell : public i::AllStatic { diff --git a/src/flags/flag-definitions.h b/src/flags/flag-definitions.h index 59d5314d13..35b055b42d 100644 --- a/src/flags/flag-definitions.h +++ b/src/flags/flag-definitions.h @@ -15,11 +15,6 @@ #define DEFINE_IMPLICATION(whenflag, thenflag) \ DEFINE_VALUE_IMPLICATION(whenflag, thenflag, true) -// A weak implication will be overwritten by a normal implication or by an -// explicit flag. -#define DEFINE_WEAK_IMPLICATION(whenflag, thenflag) \ - DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, true) - #define DEFINE_NEG_IMPLICATION(whenflag, thenflag) \ DEFINE_VALUE_IMPLICATION(whenflag, thenflag, false) @@ -64,22 +59,14 @@ // We produce the code to set flags when it is implied by another flag. #elif defined(FLAG_MODE_DEFINE_IMPLICATIONS) -#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \ - changed |= TriggerImplication(FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \ - value, false); - -// A weak implication will be overwritten by a normal implication or by an -// explicit flag. -#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) \ - changed |= TriggerImplication(FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \ - value, true); +#define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) \ + if (FLAG_##whenflag) FLAG_##thenflag = value; #define DEFINE_GENERIC_IMPLICATION(whenflag, statement) \ if (FLAG_##whenflag) statement; -#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \ - changed |= TriggerImplication(!FLAG_##whenflag, #whenflag, &FLAG_##thenflag, \ - value, false); +#define DEFINE_NEG_VALUE_IMPLICATION(whenflag, thenflag, value) \ + if (!FLAG_##whenflag) FLAG_##thenflag = value; // We apply a generic macro to the flags. #elif defined(FLAG_MODE_APPLY) @@ -107,10 +94,6 @@ #define DEFINE_VALUE_IMPLICATION(whenflag, thenflag, value) #endif -#ifndef DEFINE_WEAK_VALUE_IMPLICATION -#define DEFINE_WEAK_VALUE_IMPLICATION(whenflag, thenflag, value) -#endif - #ifndef DEFINE_GENERIC_IMPLICATION #define DEFINE_GENERIC_IMPLICATION(whenflag, statement) #endif @@ -220,14 +203,6 @@ struct MaybeBoolFlag { // #define FLAG FLAG_FULL -// ATTENTION: This is set to true by default in d8. But for API compatibility, -// it generally defaults to false. -DEFINE_BOOL(abort_on_contradictory_flags, false, - "Disallow flags or implications overriding each other.") -// This implication is also hard-coded into the flags processing to make sure it -// becomes active before we even process subsequent flags. -DEFINE_NEG_IMPLICATION(fuzzing, abort_on_contradictory_flags) - // Flags for language modes and experimental language features. DEFINE_BOOL(use_strict, false, "enforce strict mode") @@ -402,27 +377,7 @@ DEFINE_BOOL(future, FUTURE_BOOL, "Implies all staged features that we want to ship in the " "not-too-far future") -DEFINE_WEAK_IMPLICATION(future, write_protect_code_memory) - -// Flags for jitless -DEFINE_BOOL(jitless, V8_LITE_BOOL, - "Disable runtime allocation of executable memory.") - -// Jitless V8 has a few implications: -DEFINE_NEG_IMPLICATION(jitless, opt) -// Field representation tracking is only used by TurboFan. -DEFINE_NEG_IMPLICATION(jitless, track_field_types) -DEFINE_NEG_IMPLICATION(jitless, track_heap_object_fields) -// Regexps are interpreted. -DEFINE_IMPLICATION(jitless, regexp_interpret_all) -// asm.js validation is disabled since it triggers wasm code generation. -DEFINE_NEG_IMPLICATION(jitless, validate_asm) -// --jitless also implies --no-expose-wasm, see InitializeOncePerProcessImpl. - -#ifndef V8_TARGET_ARCH_ARM -// Unsupported on arm. See https://crbug.com/v8/8713. -DEFINE_NEG_IMPLICATION(jitless, interpreted_frames_native_stack) -#endif +DEFINE_IMPLICATION(future, write_protect_code_memory) DEFINE_BOOL(assert_types, false, "generate runtime type assertions to test the typer") @@ -475,6 +430,26 @@ DEFINE_BOOL_READONLY(string_slices, true, "use string slices") DEFINE_INT(interrupt_budget, 144 * KB, "interrupt budget which should be used for the profiler counter") +// Flags for jitless +DEFINE_BOOL(jitless, V8_LITE_BOOL, + "Disable runtime allocation of executable memory.") + +// Jitless V8 has a few implications: +DEFINE_NEG_IMPLICATION(jitless, opt) +// Field representation tracking is only used by TurboFan. +DEFINE_NEG_IMPLICATION(jitless, track_field_types) +DEFINE_NEG_IMPLICATION(jitless, track_heap_object_fields) +// Regexps are interpreted. +DEFINE_IMPLICATION(jitless, regexp_interpret_all) +// asm.js validation is disabled since it triggers wasm code generation. +DEFINE_NEG_IMPLICATION(jitless, validate_asm) +// --jitless also implies --no-expose-wasm, see InitializeOncePerProcessImpl. + +#ifndef V8_TARGET_ARCH_ARM +// Unsupported on arm. See https://crbug.com/v8/8713. +DEFINE_NEG_IMPLICATION(jitless, interpreted_frames_native_stack) +#endif + // Flags for inline caching and feedback vectors. DEFINE_BOOL(use_ic, true, "use inline caching") DEFINE_INT(budget_for_feedback_vector_allocation, 1 * KB, @@ -549,7 +524,7 @@ DEFINE_BOOL(concurrent_inlining, false, "run optimizing compiler's inlining phase on a separate thread") DEFINE_INT(max_serializer_nesting, 25, "maximum levels for nesting child serializers") -DEFINE_WEAK_IMPLICATION(future, concurrent_inlining) +DEFINE_IMPLICATION(future, concurrent_inlining) DEFINE_BOOL(trace_heap_broker_verbose, false, "trace the heap broker verbosely (all reports)") DEFINE_BOOL(trace_heap_broker_memory, false, @@ -1879,11 +1854,9 @@ DEFINE_IMPLICATION(unbox_double_fields, track_double_fields) #undef DEFINE_STRING #undef DEFINE_FLOAT #undef DEFINE_IMPLICATION -#undef DEFINE_WEAK_IMPLICATION #undef DEFINE_NEG_IMPLICATION #undef DEFINE_NEG_VALUE_IMPLICATION #undef DEFINE_VALUE_IMPLICATION -#undef DEFINE_WEAK_VALUE_IMPLICATION #undef DEFINE_GENERIC_IMPLICATION #undef DEFINE_ALIAS_BOOL #undef DEFINE_ALIAS_INT diff --git a/src/flags/flags.cc b/src/flags/flags.cc index 982754a946..a5dfb543d5 100644 --- a/src/flags/flags.cc +++ b/src/flags/flags.cc @@ -8,11 +8,9 @@ #include #include #include -#include #include #include "src/base/functional.h" -#include "src/base/logging.h" #include "src/base/platform/platform.h" #include "src/codegen/cpu-features.h" #include "src/logging/counters.h" @@ -35,10 +33,6 @@ namespace internal { namespace { -struct Flag; -Flag* FindFlagByPointer(const void* ptr); -Flag* FindFlagByName(const char* name); - // This structure represents a single entry in the flag system, with a pointer // to the actual flag, default value, comment, etc. This is designed to be POD // initialized as to avoid requiring static constructors. @@ -54,16 +48,12 @@ struct Flag { TYPE_STRING, }; - enum class SetBy { kDefault, kWeakImplication, kImplication, kCommandLine }; - FlagType type_; // What type of flag, bool, int, or string. const char* name_; // Name of the flag, ex "my_flag". void* valptr_; // Pointer to the global flag variable. const void* defptr_; // Pointer to the default value. const char* cmt_; // A comment about the flags purpose. bool owns_ptr_; // Does the flag own its string value? - SetBy set_by_ = SetBy::kDefault; - const char* implied_by_ = nullptr; FlagType type() const { return type_; } @@ -71,90 +61,39 @@ struct Flag { const char* comment() const { return cmt_; } - bool PointsTo(const void* ptr) const { return valptr_ == ptr; } - - bool bool_variable() const { + bool* bool_variable() const { DCHECK(type_ == TYPE_BOOL); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_bool_variable(bool value, SetBy set_by) { - DCHECK(type_ == TYPE_BOOL); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - MaybeBoolFlag maybe_bool_variable() const { + MaybeBoolFlag* maybe_bool_variable() const { DCHECK(type_ == TYPE_MAYBE_BOOL); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_maybe_bool_variable(MaybeBoolFlag value, SetBy set_by) { - DCHECK(type_ == TYPE_MAYBE_BOOL); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - int int_variable() const { + int* int_variable() const { DCHECK(type_ == TYPE_INT); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_int_variable(int value, SetBy set_by) { - DCHECK(type_ == TYPE_INT); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - unsigned int uint_variable() const { + unsigned int* uint_variable() const { DCHECK(type_ == TYPE_UINT); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_uint_variable(unsigned int value, SetBy set_by) { - DCHECK(type_ == TYPE_UINT); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - uint64_t uint64_variable() const { + uint64_t* uint64_variable() const { DCHECK(type_ == TYPE_UINT64); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_uint64_variable(uint64_t value, SetBy set_by) { - DCHECK(type_ == TYPE_UINT64); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - double float_variable() const { + double* float_variable() const { DCHECK(type_ == TYPE_FLOAT); - return *reinterpret_cast(valptr_); + return reinterpret_cast(valptr_); } - void set_float_variable(double value, SetBy set_by) { - DCHECK(type_ == TYPE_FLOAT); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; - } - - size_t size_t_variable() const { + size_t* size_t_variable() const { DCHECK(type_ == TYPE_SIZE_T); - return *reinterpret_cast(valptr_); - } - - void set_size_t_variable(size_t value, SetBy set_by) { - DCHECK(type_ == TYPE_SIZE_T); - bool change_flag = *reinterpret_cast(valptr_) != value; - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) *reinterpret_cast(valptr_) = value; + return reinterpret_cast(valptr_); } const char* string_value() const { @@ -162,19 +101,12 @@ struct Flag { return *reinterpret_cast(valptr_); } - void set_string_value(const char* value, bool owns_ptr, SetBy set_by) { + void set_string_value(const char* value, bool owns_ptr) { DCHECK(type_ == TYPE_STRING); const char** ptr = reinterpret_cast(valptr_); - bool change_flag = (*ptr == nullptr) != (value == nullptr) || - (*ptr && value && std::strcmp(*ptr, value) != 0); - change_flag = CheckFlagChange(set_by, change_flag); - if (change_flag) { - if (owns_ptr_ && *ptr != nullptr) DeleteArray(*ptr); - *ptr = value; - owns_ptr_ = owns_ptr; - } else { - if (owns_ptr && value != nullptr) DeleteArray(value); - } + if (owns_ptr_ && *ptr != nullptr) DeleteArray(*ptr); + *ptr = value; + owns_ptr_ = owns_ptr; } bool bool_default() const { @@ -212,95 +144,23 @@ struct Flag { return *reinterpret_cast(defptr_); } - static bool ShouldCheckFlagContradictions() { - return FLAG_abort_on_contradictory_flags && !FLAG_fuzzing; - } - - // {change_flag} indicates if we're going to change the flag value. - // Returns an updated value for {change_flag}, which is changed to false if a - // weak implication is being ignored beause a flag is already set by a normal - // implication or from the command-line. - bool CheckFlagChange(SetBy new_set_by, bool change_flag, - const char* implied_by = nullptr) { - if (new_set_by == SetBy::kWeakImplication && - (set_by_ == SetBy::kImplication || set_by_ == SetBy::kCommandLine)) { - return false; - } - if (ShouldCheckFlagContradictions()) { - // For bool flags, we only check for a conflict if the value actually - // changes. So specifying the same flag with the same value multiple times - // is allowed. - // For other flags, we disallow specifying them explicitly or in the - // presence of an implication even if the value is the same. - // This is to simplify the rules describing conflicts in variants.py: A - // repeated non-boolean flag is considered an error independently of its - // value. - bool is_bool_flag = type_ == TYPE_MAYBE_BOOL || type_ == TYPE_BOOL; - bool check_implications = change_flag; - bool check_command_line_flags = change_flag || !is_bool_flag; - const char* hint = - "To fix this, it might be necessary to specify additional " - "contradictory flags in tools/testrunner/local/variants.py."; - switch (set_by_) { - case SetBy::kDefault: - break; - case SetBy::kWeakImplication: - if (new_set_by == SetBy::kWeakImplication && check_implications) { - FATAL( - "Contradictory weak flag implications from --%s and --%s for " - "flag %s\n%s", - implied_by_, implied_by, name(), hint); - } - break; - case SetBy::kImplication: - if (new_set_by == SetBy::kImplication && check_implications) { - FATAL( - "Contradictory flag implications from --%s and --%s for flag " - "%s\n%s", - implied_by_, implied_by, name(), hint); - } - break; - case SetBy::kCommandLine: - if (new_set_by == SetBy::kImplication && check_command_line_flags) { - FATAL( - "Flag --%s is implied by --%s but also specified " - "explicitly.\n%s", - name(), implied_by, hint); - } else if (new_set_by == SetBy::kCommandLine && - check_command_line_flags) { - FATAL( - "Command-line provided flag --%s specified multiple times.\n%s", - name(), hint); - } - break; - } - } - set_by_ = new_set_by; - if (new_set_by == SetBy::kImplication || - new_set_by == SetBy::kWeakImplication) { - DCHECK_NOT_NULL(implied_by); - implied_by_ = implied_by; - } - return change_flag; - } - // Compare this flag's current value against the default. bool IsDefault() const { switch (type_) { case TYPE_BOOL: - return bool_variable() == bool_default(); + return *bool_variable() == bool_default(); case TYPE_MAYBE_BOOL: - return maybe_bool_variable().has_value == false; + return maybe_bool_variable()->has_value == false; case TYPE_INT: - return int_variable() == int_default(); + return *int_variable() == int_default(); case TYPE_UINT: - return uint_variable() == uint_default(); + return *uint_variable() == uint_default(); case TYPE_UINT64: - return uint64_variable() == uint64_default(); + return *uint64_variable() == uint64_default(); case TYPE_FLOAT: - return float_variable() == float_default(); + return *float_variable() == float_default(); case TYPE_SIZE_T: - return size_t_variable() == size_t_default(); + return *size_t_variable() == size_t_default(); case TYPE_STRING: { const char* str1 = string_value(); const char* str2 = string_default(); @@ -316,34 +176,31 @@ struct Flag { void Reset() { switch (type_) { case TYPE_BOOL: - set_bool_variable(bool_default(), SetBy::kDefault); + *bool_variable() = bool_default(); break; case TYPE_MAYBE_BOOL: - set_maybe_bool_variable(MaybeBoolFlag::Create(false, false), - SetBy::kDefault); + *maybe_bool_variable() = MaybeBoolFlag::Create(false, false); break; case TYPE_INT: - set_int_variable(int_default(), SetBy::kDefault); + *int_variable() = int_default(); break; case TYPE_UINT: - set_uint_variable(uint_default(), SetBy::kDefault); + *uint_variable() = uint_default(); break; case TYPE_UINT64: - set_uint64_variable(uint64_default(), SetBy::kDefault); + *uint64_variable() = uint64_default(); break; case TYPE_FLOAT: - set_float_variable(float_default(), SetBy::kDefault); + *float_variable() = float_default(); break; case TYPE_SIZE_T: - set_size_t_variable(size_t_default(), SetBy::kDefault); + *size_t_variable() = size_t_default(); break; case TYPE_STRING: - set_string_value(string_default(), false, SetBy::kDefault); + set_string_value(string_default(), false); break; } } - - void AllowOverwriting() { set_by_ = SetBy::kDefault; } }; Flag flags[] = { @@ -353,31 +210,6 @@ Flag flags[] = { const size_t num_flags = sizeof(flags) / sizeof(*flags); -inline char NormalizeChar(char ch) { return ch == '_' ? '-' : ch; } - -bool EqualNames(const char* a, const char* b) { - for (int i = 0; NormalizeChar(a[i]) == NormalizeChar(b[i]); i++) { - if (a[i] == '\0') { - return true; - } - } - return false; -} - -Flag* FindFlagByName(const char* name) { - for (size_t i = 0; i < num_flags; ++i) { - if (EqualNames(name, flags[i].name())) return &flags[i]; - } - return nullptr; -} - -Flag* FindFlagByPointer(const void* ptr) { - for (size_t i = 0; i < num_flags; ++i) { - if (flags[i].PointsTo(ptr)) return &flags[i]; - } - return nullptr; -} - } // namespace static const char* Type2String(Flag::FlagType type) { @@ -405,27 +237,27 @@ static const char* Type2String(Flag::FlagType type) { std::ostream& operator<<(std::ostream& os, const Flag& flag) { // NOLINT switch (flag.type()) { case Flag::TYPE_BOOL: - os << (flag.bool_variable() ? "true" : "false"); + os << (*flag.bool_variable() ? "true" : "false"); break; case Flag::TYPE_MAYBE_BOOL: - os << (flag.maybe_bool_variable().has_value - ? (flag.maybe_bool_variable().value ? "true" : "false") + os << (flag.maybe_bool_variable()->has_value + ? (flag.maybe_bool_variable()->value ? "true" : "false") : "unset"); break; case Flag::TYPE_INT: - os << flag.int_variable(); + os << *flag.int_variable(); break; case Flag::TYPE_UINT: - os << flag.uint_variable(); + os << *flag.uint_variable(); break; case Flag::TYPE_UINT64: - os << flag.uint64_variable(); + os << *flag.uint64_variable(); break; case Flag::TYPE_FLOAT: - os << flag.float_variable(); + os << *flag.float_variable(); break; case Flag::TYPE_SIZE_T: - os << flag.size_t_variable(); + os << *flag.size_t_variable(); break; case Flag::TYPE_STRING: { const char* str = flag.string_value(); @@ -443,7 +275,7 @@ std::vector* FlagList::argv() { Flag* f = &flags[i]; if (!f->IsDefault()) { { - bool disabled = f->type() == Flag::TYPE_BOOL && !f->bool_variable(); + bool disabled = f->type() == Flag::TYPE_BOOL && !*f->bool_variable(); std::ostringstream os; os << (disabled ? "--no" : "--") << f->name(); args->push_back(StrDup(os.str().c_str())); @@ -458,6 +290,8 @@ std::vector* FlagList::argv() { return args; } +inline char NormalizeChar(char ch) { return ch == '_' ? '-' : ch; } + // Helper function to parse flags: Takes an argument arg and splits it into // a flag name and flag value (or nullptr if they are missing). negated is set // if the arg started with "-no" or "--no". The buffer may be used to NUL- @@ -500,6 +334,22 @@ static void SplitArgument(const char* arg, char* buffer, int buffer_size, } } +static bool EqualNames(const char* a, const char* b) { + for (int i = 0; NormalizeChar(a[i]) == NormalizeChar(b[i]); i++) { + if (a[i] == '\0') { + return true; + } + } + return false; +} + +static Flag* FindFlag(const char* name) { + for (size_t i = 0; i < num_flags; ++i) { + if (EqualNames(name, flags[i].name())) return &flags[i]; + } + return nullptr; +} + template bool TryParseUnsigned(Flag* flag, const char* arg, const char* value, char** endp, T* out_val) { @@ -538,7 +388,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags, if (name != nullptr) { // lookup the flag - Flag* flag = FindFlagByName(name); + Flag* flag = FindFlag(name); if (flag == nullptr) { if (remove_flags) { // We don't recognize this flag but since we're removing @@ -571,50 +421,37 @@ int FlagList::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags, char* endp = const_cast(""); // *endp is only read switch (flag->type()) { case Flag::TYPE_BOOL: - flag->set_bool_variable(!negated, Flag::SetBy::kCommandLine); + *flag->bool_variable() = !negated; break; case Flag::TYPE_MAYBE_BOOL: - flag->set_maybe_bool_variable(MaybeBoolFlag::Create(true, !negated), - Flag::SetBy::kCommandLine); + *flag->maybe_bool_variable() = MaybeBoolFlag::Create(true, !negated); break; case Flag::TYPE_INT: - flag->set_int_variable(static_cast(strtol(value, &endp, 10)), - Flag::SetBy::kCommandLine); + *flag->int_variable() = static_cast(strtol(value, &endp, 10)); break; - case Flag::TYPE_UINT: { - unsigned int parsed_value; - if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) { - flag->set_uint_variable(parsed_value, Flag::SetBy::kCommandLine); - } else { + case Flag::TYPE_UINT: + if (!TryParseUnsigned(flag, arg, value, &endp, + flag->uint_variable())) { return_code = j; } break; - } - case Flag::TYPE_UINT64: { - uint64_t parsed_value; - if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) { - flag->set_uint64_variable(parsed_value, Flag::SetBy::kCommandLine); - } else { + case Flag::TYPE_UINT64: + if (!TryParseUnsigned(flag, arg, value, &endp, + flag->uint64_variable())) { return_code = j; } break; - } case Flag::TYPE_FLOAT: - flag->set_float_variable(strtod(value, &endp), - Flag::SetBy::kCommandLine); + *flag->float_variable() = strtod(value, &endp); break; - case Flag::TYPE_SIZE_T: { - size_t parsed_value; - if (TryParseUnsigned(flag, arg, value, &endp, &parsed_value)) { - flag->set_size_t_variable(parsed_value, Flag::SetBy::kCommandLine); - } else { + 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, - Flag::SetBy::kCommandLine); + flag->set_string_value(value ? StrDup(value) : nullptr, true); break; } @@ -751,8 +588,6 @@ void FlagList::PrintHelp() { } } -namespace { - static uint32_t flag_hash = 0; void ComputeFlagListHash() { @@ -765,7 +600,8 @@ void ComputeFlagListHash() { } for (size_t i = 0; i < num_flags; ++i) { Flag* current = &flags[i]; - if (current->PointsTo(&FLAG_profile_deserialization)) { + if (current->type() == Flag::TYPE_BOOL && + current->bool_variable() == &FLAG_profile_deserialization) { // We want to be able to flip --profile-deserialization without // causing the code cache to get invalidated by this hash. continue; @@ -780,31 +616,11 @@ void ComputeFlagListHash() { base::hash_range(args.c_str(), args.c_str() + args.length())); } -template -bool TriggerImplication(bool premise, const char* premise_name, - A* conclusion_pointer, B value, bool weak_implication) { - if (!premise) return false; - bool change_flag = *conclusion_pointer != implicit_cast(value); - Flag* conclusion_flag = FindFlagByPointer(conclusion_pointer); - change_flag = conclusion_flag->CheckFlagChange( - weak_implication ? Flag::SetBy::kWeakImplication - : Flag::SetBy::kImplication, - change_flag, premise_name); - if (change_flag) *conclusion_pointer = value; - return change_flag; -} - -} // namespace - // static void FlagList::EnforceFlagImplications() { - bool changed; - do { - changed = false; #define FLAG_MODE_DEFINE_IMPLICATIONS #include "src/flags/flag-definitions.h" // NOLINT(build/include) #undef FLAG_MODE_DEFINE_IMPLICATIONS - } while (changed); ComputeFlagListHash(); } diff --git a/test/inspector/inspector-test.cc b/test/inspector/inspector-test.cc index e96fece15f..5946418665 100644 --- a/test/inspector/inspector-test.cc +++ b/test/inspector/inspector-test.cc @@ -1057,7 +1057,6 @@ int main(int argc, char* argv[]) { v8::V8::InitializeICUDefaultLocation(argv[0]); std::unique_ptr platform(v8::platform::NewDefaultPlatform()); v8::V8::InitializePlatform(platform.get()); - v8::internal::FLAG_abort_on_contradictory_flags = true; v8::V8::SetFlagsFromCommandLine(&argc, argv, true); v8::V8::InitializeExternalStartupData(argv[0]); v8::V8::Initialize(); diff --git a/test/inspector/inspector.status b/test/inspector/inspector.status index 9d3467d599..d969c6815f 100644 --- a/test/inspector/inspector.status +++ b/test/inspector/inspector.status @@ -91,11 +91,6 @@ '*': [SKIP], # only relevant for mjsunit tests. }], -################################################################################ -['variant == stress', { - '*': [SKIP], # only relevant for mjsunit tests. -}], - ############################################################################## ['tsan == True', { # TSan handles SIGPROF incorrectly (https://crbug.com/v8/9869). diff --git a/test/message/wasm-trace-memory-liftoff.js b/test/message/wasm-trace-memory-liftoff.js index ad1b9e4042..05c30a219e 100644 --- a/test/message/wasm-trace-memory-liftoff.js +++ b/test/message/wasm-trace-memory-liftoff.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --no-stress-opt --trace-wasm-memory --liftoff +// Flags: --no-stress-opt --trace-wasm-memory --liftoff --no-future // Flags: --no-wasm-tier-up --experimental-wasm-simd // Flags: --enable-sse3 --enable-sse4-1 diff --git a/test/message/wasm-trace-memory.js b/test/message/wasm-trace-memory.js index b31dbb8e1f..b268c63106 100644 --- a/test/message/wasm-trace-memory.js +++ b/test/message/wasm-trace-memory.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --no-stress-opt --trace-wasm-memory --no-liftoff +// Flags: --no-stress-opt --trace-wasm-memory --no-liftoff --no-future // Flags: --experimental-wasm-simd load("test/mjsunit/wasm/wasm-module-builder.js"); diff --git a/test/mjsunit/ensure-growing-store-learns.js b/test/mjsunit/ensure-growing-store-learns.js index 6b697dbdf7..5340919472 100644 --- a/test/mjsunit/ensure-growing-store-learns.js +++ b/test/mjsunit/ensure-growing-store-learns.js @@ -2,15 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// The flags are processed left to right. --no-abort-on-contradictory-flags -// disables the checking for conflicts, then we process --noverify-heap and -// --noenable-slow-asserts, which the test runner already set to true before. -// This causes the flags to be overwritten while silencing the error. Then we -// re-enable --abort-on-contradictory-flags to make sure that the processing of -// other flags and flag implications, which happens later, still produces -// errors. -// Flags: --no-abort-on-contradictory-flags --noverify-heap --noenable-slow-asserts --abort-on-contradictory-flags -// Flags: --allow-natives-syntax --opt --no-always-opt +// Flags: --allow-natives-syntax --noverify-heap --noenable-slow-asserts +// Flags: --opt --no-always-opt // --noverify-heap and --noenable-slow-asserts are set because the test is too // slow with it on. diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status index b0a2efa2ce..9e16c4b738 100644 --- a/test/mjsunit/mjsunit.status +++ b/test/mjsunit/mjsunit.status @@ -376,6 +376,17 @@ 'regexp-tier-up-multiple': [SKIP], 'regress/regress-996234': [SKIP], + # Tests that depend on optimization (beyond doing assertOptimized). + 'compiler/is-being-interpreted-*': [SKIP], + 'compiler/serializer-accessors': [SKIP], + 'compiler/serializer-apply': [SKIP], + 'compiler/serializer-call': [SKIP], + 'compiler/serializer-dead-after-jump': [SKIP], + 'compiler/serializer-dead-after-return': [SKIP], + 'compiler/serializer-transition-propagation': [SKIP], + 'regress/regress-1049982-1': [SKIP], + 'regress/regress-1049982-2': [SKIP], + # These tests check that we can trace the compiler. 'tools/compiler-trace-flags': [SKIP], 'tools/compiler-trace-flags-wasm': [SKIP], @@ -1166,6 +1177,10 @@ 'regress/regress-1049982-2': [SKIP], 'es6/iterator-eager-deopt': [SKIP], + # interrupt_budget overrides don't work with TurboProp. + 'interrupt-budget-override': [SKIP], + 'never-optimize': [SKIP], + # In turboprop we reuse the optimized code on soft deopt. The following tests # test for a soft deopt and they won't work in TurboProp. 'deopt-recursive-soft-once': [SKIP], diff --git a/test/mjsunit/random-bit-correlations.js b/test/mjsunit/random-bit-correlations.js index 301c50abeb..2ac84c54a7 100644 --- a/test/mjsunit/random-bit-correlations.js +++ b/test/mjsunit/random-bit-correlations.js @@ -2,15 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Overwrite the random seed provided by the test runner to make this test less -// flaky. -// The flags are processed left to right. --no-abort-on-contradictory-flags -// disables the checking for conflicts, then we process --random-seed=20 to -// overwrite the value the test runner already set before. Then we re-enable -// --abort-on-contradictory-flags to make sure that the processing of other -// flags and flag implications, which happens later, still produces errors. -// Flags: --no-abort-on-contradictory-flags --random-seed=20 --abort-on-contradictory-flags -// Flags: --nostress-opt --noalways-opt --predictable +// Flags: --random-seed=20 --nostress-opt --noalways-opt --predictable (function() { var kHistory = 2; diff --git a/test/mjsunit/regress/regress-356053.js b/test/mjsunit/regress/regress-356053.js index ea84973d8e..2695c48fd1 100644 --- a/test/mjsunit/regress/regress-356053.js +++ b/test/mjsunit/regress/regress-356053.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --expose-gc --allow-natives-syntax +// Flags: --noconcurrent-recompilation --expose-gc --allow-natives-syntax // Flags: --concurrent-recompilation --block-concurrent-recompilation gc(); diff --git a/test/mjsunit/regress/regress-411210.js b/test/mjsunit/regress/regress-411210.js index b977beb3c8..2dbc5ff70c 100644 --- a/test/mjsunit/regress/regress-411210.js +++ b/test/mjsunit/regress/regress-411210.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --gc-interval=439 +// Flags: --allow-natives-syntax --gc-interval=439 --random-seed=-423594851 var __v_3; function __f_2() { diff --git a/test/mjsunit/regress/regress-487981.js b/test/mjsunit/regress/regress-487981.js index 65266dcfa4..f548944ba7 100644 --- a/test/mjsunit/regress/regress-487981.js +++ b/test/mjsunit/regress/regress-487981.js @@ -4,7 +4,7 @@ // Flags: --allow-natives-syntax --stress-compaction -// To reliably reproduce the crash use --verify-heap +// To reliably reproduce the crash use --verify-heap --random-seed=-133185440 function __f_2(o) { return o.field.b.x; diff --git a/test/mjsunit/regress/regress-8265.js b/test/mjsunit/regress/regress-8265.js index 0be0926012..ffe6191c9f 100644 --- a/test/mjsunit/regress/regress-8265.js +++ b/test/mjsunit/regress/regress-8265.js @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +// Flags: --random-seed=1 + for (let i = 0; i < 54; ++i) Math.random(); let sum = 0; for (let i = 0; i < 10; ++i) diff --git a/test/mjsunit/regress/regress-863810.js b/test/mjsunit/regress/regress-863810.js index 841909a207..07c0599231 100644 --- a/test/mjsunit/regress/regress-863810.js +++ b/test/mjsunit/regress/regress-863810.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --no-liftoff --debug-code +// Flags: --no-liftoff --no-future --debug-code load('test/mjsunit/wasm/wasm-module-builder.js'); diff --git a/test/mjsunit/regress/regress-883059.js b/test/mjsunit/regress/regress-883059.js index d7be11038b..ed70feddb4 100644 --- a/test/mjsunit/regress/regress-883059.js +++ b/test/mjsunit/regress/regress-883059.js @@ -2,6 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --disable-in-process-stack-traces --no-lazy +// Flags: --random-seed=-1595876594 --disable-in-process-stack-traces --no-lazy var __v_47 = ({[__v_46]: __f_52}) => { var __v_46 = 'b'; return __f_52; }; diff --git a/test/mjsunit/regress/regress-crbug-664506.js b/test/mjsunit/regress/regress-crbug-664506.js index 44ae933027..b0bf5e7591 100644 --- a/test/mjsunit/regress/regress-crbug-664506.js +++ b/test/mjsunit/regress/regress-crbug-664506.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --expose-gc --predictable +// Flags: --expose-gc --predictable --random-seed=-1109634722 gc(); gc(); diff --git a/test/mjsunit/regress/wasm/regress-02256.js b/test/mjsunit/regress/wasm/regress-02256.js index aaf508f2bd..63da0cc10b 100644 --- a/test/mjsunit/regress/wasm/regress-02256.js +++ b/test/mjsunit/regress/wasm/regress-02256.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // -// Flags: --expose-gc --allow-natives-syntax +// Flags: --random-seed=891196975 --expose-gc --allow-natives-syntax // Flags: --gc-interval=207 --stress-compaction --validate-asm // Flags: --opt --no-always-opt // diff --git a/test/mjsunit/regress/wasm/regress-02256b.js b/test/mjsunit/regress/wasm/regress-02256b.js index a9619c5359..249e96dfef 100644 --- a/test/mjsunit/regress/wasm/regress-02256b.js +++ b/test/mjsunit/regress/wasm/regress-02256b.js @@ -2,8 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // -// Flags: --expose-gc --allow-natives-syntax --gc-interval=207 -// Flags: --stress-compaction --validate-asm --opt --no-always-opt +// Flags: --random-seed=891196975 --expose-gc --allow-natives-syntax +// Flags: --gc-interval=207 --stress-compaction --validate-asm +// Flags: --opt --no-always-opt // // /v8/test/mjsunit/wasm/grow-memory.js // /v8/test/mjsunit/regress/regress-540.js diff --git a/test/mjsunit/regress/wasm/regress-02862.js b/test/mjsunit/regress/wasm/regress-02862.js index d6c5e07536..92ed1cd6c9 100644 --- a/test/mjsunit/regress/wasm/regress-02862.js +++ b/test/mjsunit/regress/wasm/regress-02862.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --expose-gc --invoke-weak-callbacks --omit-quit --gc-interval=469 --validate-asm +// Flags: --random-seed=1557792826 --expose-gc --invoke-weak-callbacks --omit-quit --gc-interval=469 --validate-asm function nop() {} var __v_42 = {}; diff --git a/test/mjsunit/regress/wasm/regress-666741.js b/test/mjsunit/regress/wasm/regress-666741.js index 2fff1bec79..0f9ae9a607 100644 --- a/test/mjsunit/regress/wasm/regress-666741.js +++ b/test/mjsunit/regress/wasm/regress-666741.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // -// Flags: --enable-slow-asserts --expose-wasm +// Flags: --random-seed=-1101427159 --enable-slow-asserts --expose-wasm (function __f_7() { assertThrows(() => new WebAssembly.Memory({initial: 79199}), RangeError); diff --git a/test/mjsunit/string-case.js b/test/mjsunit/string-case.js index 4bc169cad3..b6934eb705 100644 --- a/test/mjsunit/string-case.js +++ b/test/mjsunit/string-case.js @@ -25,7 +25,8 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// Flags: --allow-natives-syntax --expose-externalize-string +// Flags: --random-seed=17 --allow-natives-syntax +// Flags: --expose-externalize-string assertEquals("ΚΟΣΜΟΣ ΚΟΣΜΟΣ".toLowerCase(), "κοσμος κοσμος"); diff --git a/test/mjsunit/wasm/tier-up-testing-flag.js b/test/mjsunit/wasm/tier-up-testing-flag.js index d25124ddb1..20aa30930c 100644 --- a/test/mjsunit/wasm/tier-up-testing-flag.js +++ b/test/mjsunit/wasm/tier-up-testing-flag.js @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Flags: --allow-natives-syntax --liftoff --no-wasm-tier-up +// Flags: --allow-natives-syntax --liftoff --no-future --no-wasm-tier-up // Compile functions 0 and 2 with Turbofan, the rest with Liftoff: // Flags: --wasm-tier-mask-for-testing=5 diff --git a/tools/testrunner/local/statusfile.py b/tools/testrunner/local/statusfile.py index 854abc6655..c8a1b307e4 100644 --- a/tools/testrunner/local/statusfile.py +++ b/tools/testrunner/local/statusfile.py @@ -76,7 +76,6 @@ class StatusFile(object): _rules: {variant: {test name: [rule]}} _prefix_rules: {variant: {test name prefix: [rule]}} """ - self.variables = variables with open(path) as f: self._rules, self._prefix_rules = ReadStatusFile(f.read(), variables) diff --git a/tools/testrunner/local/variants.py b/tools/testrunner/local/variants.py index cc6e623e65..7c0e2969fd 100644 --- a/tools/testrunner/local/variants.py +++ b/tools/testrunner/local/variants.py @@ -25,7 +25,8 @@ ALL_VARIANT_FLAGS = { # independent of JS optimizations, so we can combine those configs. "nooptimization": [["--no-opt", "--liftoff", "--no-wasm-tier-up"]], "slow_path": [["--force-slow-path"]], - "stress": [["--stress-opt", "--no-liftoff", "--stress-lazy-source-positions"]], + "stress": [["--stress-opt", "--always-opt", "--no-liftoff", + "--stress-lazy-source-positions"]], "stress_js_bg_compile_wasm_code_gc": [["--stress-background-compile", "--stress-wasm-code-gc"]], "stress_incremental_marking": [["--stress-incremental-marking"]], @@ -40,51 +41,6 @@ ALL_VARIANT_FLAGS = { "top_level_await": [["--harmony-top-level-await"]], } -# Flags that lead to a contradiction with the flags provided by the respective -# variant. This depends on the flags specified in ALL_VARIANT_FLAGS and on the -# implications defined in flag-definitions.h. -INCOMPATIBLE_FLAGS_PER_VARIANT = { - "assert_types": ["--no-assert-types"], - "jitless": ["--opt", "--liftoff", "--track-field-types", "--validate-asm"], - "no_wasm_traps": ["--wasm-trap-handler"], - "nooptimization": ["--opt", "--no-liftoff", "--predictable", "--wasm-tier-up"], - "slow_path": ["--no-force-slow-path"], - "stress_incremental_marking": ["--no-stress-incremental-marking"], - "stress_js_bg_compile_wasm_code_gc": ["--no-stress-background-compile"], - "stress": ["--no-stress-opt", "--always-opt", "--no-always-opt", "--liftoff", "--max-inlined-bytecode-size=*", - "--max-inlined-bytecode-size-cumulative=*", "--stress-inline"], - "turboprop": ["--turbo-inlining", "--interrupt-budget=*", "--no-turboprop"], -} - -# Flags that lead to a contradiction under certain build variables. -# This corresponds to the build variables usable in status files as generated -# in _get_statusfile_variables in base_runner.py. -# The conflicts might be directly contradictory flags or be caused by the -# implications defined in flag-definitions.h. -INCOMPATIBLE_FLAGS_PER_BUILD_VARIABLE = { - "lite_mode": ["--no-lazy-feedback-allocation", "--max-semi-space-size=*"] - + INCOMPATIBLE_FLAGS_PER_VARIANT["jitless"], - "predictable": ["--liftoff", "--parallel-compile-tasks", - "--concurrent-recompilation", - "--wasm-num-compilation-tasks=*"], -} - -# Flags that lead to a contradiction when a certain extra-flag is present. -# Such extra-flags are defined for example in infra/testing/builders.pyl or in -# standard_runner.py. -# The conflicts might be directly contradictory flags or be caused by the -# implications defined in flag-definitions.h. -INCOMPATIBLE_FLAGS_PER_EXTRA_FLAG = { - "--concurrent-recompilation": ["--no-concurrent-recompilation", "--predictable"], - "--enable-armv8": ["--no-enable-armv8"], - "--gc-interval=*": ["--gc-interval=*"], - "--no-enable-sse3": ["--enable-sse3"], - "--no-enable-sse4-1": ["--enable-sse4-1"], - "--optimize-for-size": ["--max-semi-space-size=*"], - "--stress-flush-bytecode": ["--no-stress-flush-bytecode"], - "--stress-incremental-marking": INCOMPATIBLE_FLAGS_PER_VARIANT["stress_incremental_marking"], -} - SLOW_VARIANTS = set([ 'stress', 'stress_snapshot', diff --git a/tools/testrunner/objects/testcase.py b/tools/testrunner/objects/testcase.py index 3ad38ffc31..ac4defd2d7 100644 --- a/tools/testrunner/objects/testcase.py +++ b/tools/testrunner/objects/testcase.py @@ -34,10 +34,6 @@ from ..outproc import base as outproc from ..local import command from ..local import statusfile from ..local import utils -from ..local.variants import INCOMPATIBLE_FLAGS_PER_VARIANT -from ..local.variants import INCOMPATIBLE_FLAGS_PER_BUILD_VARIABLE -from ..local.variants import INCOMPATIBLE_FLAGS_PER_EXTRA_FLAG - FLAGS_PATTERN = re.compile(r"//\s+Flags:(.*)") @@ -88,8 +84,7 @@ class TestCase(object): # Outcomes self._statusfile_outcomes = None - self._expected_outcomes = None - self._checked_flag_contradictions = False + self.expected_outcomes = None self._statusfile_flags = None self._prepare_outcomes() @@ -121,7 +116,7 @@ class TestCase(object): outcomes = self.suite.statusfile.get_outcomes(self.name, self.variant) self._statusfile_outcomes = filter(not_flag, outcomes) self._statusfile_flags = filter(is_flag, outcomes) - self._expected_outcomes = ( + self.expected_outcomes = ( self._parse_status_file_outcomes(self._statusfile_outcomes)) def _parse_status_file_outcomes(self, outcomes): @@ -146,45 +141,6 @@ class TestCase(object): return outproc.OUTCOMES_FAIL return expected_outcomes or outproc.OUTCOMES_PASS - @property - def expected_outcomes(self): - def normalize_flag(flag): - return flag.replace("_", "-").replace("--no-", "--no") - - def has_flag(conflicting_flag, flags): - conflicting_flag = normalize_flag(conflicting_flag) - if conflicting_flag in flags: - return True - if conflicting_flag.endswith("*"): - return any(flag.startswith(conflicting_flag[:-1]) for flag in flags) - return False - - if not self._checked_flag_contradictions: - self._checked_flag_contradictions = True - - file_specific_flags = (self._get_source_flags() + self._get_suite_flags() - + self._get_statusfile_flags()) - file_specific_flags = [normalize_flag(flag) for flag in file_specific_flags] - extra_flags = [normalize_flag(flag) for flag in self._get_extra_flags()] - - incompatible_flags = [] - - if self.variant in INCOMPATIBLE_FLAGS_PER_VARIANT: - incompatible_flags += INCOMPATIBLE_FLAGS_PER_VARIANT[self.variant] - - for variable, flags in INCOMPATIBLE_FLAGS_PER_BUILD_VARIABLE.items(): - if self.suite.statusfile.variables[variable]: - incompatible_flags += flags - - for extra_flag, flags in INCOMPATIBLE_FLAGS_PER_EXTRA_FLAG.items(): - if has_flag(extra_flag, extra_flags): - incompatible_flags += flags - - for incompatible_flag in incompatible_flags: - if has_flag(incompatible_flag, file_specific_flags): - self._expected_outcomes = outproc.OUTCOMES_FAIL - return self._expected_outcomes - @property def do_skip(self): return (statusfile.SKIP in self._statusfile_outcomes and