Reverse the direction of implications for the --local-heap flag

Since the flag is enabled by default, it is more useful to have the
reverse implications so that disabling the flag is guaranteed to work.

Bug: v8:10315
Change-Id: I191c35682442925f3fed691460d074ba6715fc99
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2409498
Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Dominik Inführ <dinfuehr@chromium.org>
Reviewed-by: Georg Neis <neis@chromium.org>
Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#70022}

src/flags/flag-definitions.h

@@ -567,7 +567,6 @@ DEFINE_BOOL(concurrent_inlining, false,
 DEFINE_BOOL(turbo_direct_heap_access, false,
             "access kNeverSerialized objects directly from the heap")
 DEFINE_IMPLICATION(concurrent_inlining, turbo_direct_heap_access)
-DEFINE_IMPLICATION(turbo_direct_heap_access, local_heaps)
 DEFINE_INT(max_serializer_nesting, 25,
            "maximum levels for nesting child serializers")
 DEFINE_WEAK_IMPLICATION(future, concurrent_inlining)
@@ -1000,12 +999,17 @@ DEFINE_BOOL(concurrent_marking, V8_CONCURRENT_MARKING_BOOL,
 DEFINE_BOOL(concurrent_array_buffer_sweeping, true,
             "concurrently sweep array buffers")
 DEFINE_BOOL(concurrent_allocation, true, "concurrently allocate in old space")
-DEFINE_BOOL(local_heaps, true, "allow heap access from background tasks")
-DEFINE_IMPLICATION(concurrent_inlining, local_heaps)
 DEFINE_BOOL(stress_concurrent_allocation, false,
             "start background threads that allocate memory")
-DEFINE_IMPLICATION(stress_concurrent_allocation, concurrent_allocation)
-DEFINE_IMPLICATION(stress_concurrent_allocation, local_heaps)
+DEFINE_BOOL(local_heaps, true, "allow heap access from background tasks")
+// Since the local_heaps flag is enabled by default, we defined reverse
+// implications to simplify disabling the flag.
+DEFINE_NEG_NEG_IMPLICATION(local_heaps, turbo_direct_heap_access)
+DEFINE_NEG_NEG_IMPLICATION(local_heaps, concurrent_inlining)
+DEFINE_NEG_NEG_IMPLICATION(local_heaps, concurrent_allocation)
+DEFINE_NEG_NEG_IMPLICATION(concurrent_allocation,
+                           finalize_streaming_on_background)
+DEFINE_NEG_NEG_IMPLICATION(concurrent_allocation, stress_concurrent_allocation)
 DEFINE_BOOL(parallel_marking, V8_CONCURRENT_MARKING_BOOL,
             "use parallel marking in atomic pause")
 DEFINE_INT(ephemeron_fixpoint_iterations, 10,
@@ -1201,8 +1205,6 @@ DEFINE_BOOL(stress_background_compile, false,
 DEFINE_BOOL(
     finalize_streaming_on_background, false,
     "perform the script streaming finalization on the background thread")
-DEFINE_IMPLICATION(finalize_streaming_on_background, concurrent_allocation)
-DEFINE_IMPLICATION(finalize_streaming_on_background, local_heaps)
 DEFINE_BOOL(disable_old_api_accessors, false,
             "Disable old-style API accessors whose setters trigger through the "
             "prototype chain")

test/cctest/compiler/serializer-tester.cc

@@ -22,6 +22,10 @@ SerializerTester::SerializerTester(const char* source)
     : canonical_(main_isolate()) {
   // The tests only make sense in the context of concurrent compilation.
   FLAG_concurrent_inlining = true;
+  // --local-heaps is enabled by default, but some bots disable it.
+  // Ensure that it is enabled here because we have reverse implication
+  // from --no-local-heaps to --no-concurrent-inlining.
+  FLAG_local_heaps = true;
   // The tests don't make sense when optimizations are turned off.
   FLAG_opt = true;
   // We need the IC to feed it to the serializer.