[compiler] Remove support for --no-concurrent-inlining

Now that concurrent inlining is shipping on stable, remove support
--no-concurrent-inlining.

Note that it's still possible to run Turbofan exclusively on the
main thread by passing --no-concurrent-recompilation.

Bug: v8:7790, v8:12142, chromium:1240585
Change-Id: I1943bbbcad7dea7e3a3c337c239f14f7d96c23cd
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3308798
Reviewed-by: Liviu Rau <liviurau@chromium.org>
Reviewed-by: Maya Lekova <mslekova@chromium.org>
Commit-Queue: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78644}

BUILD.bazel

@@ -2600,8 +2600,6 @@ filegroup(
         "src/compiler/js-graph.h",
         "src/compiler/js-heap-broker.cc",
         "src/compiler/js-heap-broker.h",
-        "src/compiler/js-heap-copy-reducer.cc",
-        "src/compiler/js-heap-copy-reducer.h",
         "src/compiler/js-inlining.cc",
         "src/compiler/js-inlining.h",
         "src/compiler/js-inlining-heuristic.cc",

BUILD.gn

@@ -2784,7 +2784,6 @@ v8_header_set("v8_internal_headers") {
     "src/compiler/js-generic-lowering.h",
     "src/compiler/js-graph.h",
     "src/compiler/js-heap-broker.h",
-    "src/compiler/js-heap-copy-reducer.h",
     "src/compiler/js-inlining-heuristic.h",
     "src/compiler/js-inlining.h",
     "src/compiler/js-intrinsic-lowering.h",
@@ -3845,7 +3844,6 @@ v8_compiler_sources = [
   "src/compiler/js-generic-lowering.cc",
   "src/compiler/js-graph.cc",
   "src/compiler/js-heap-broker.cc",
-  "src/compiler/js-heap-copy-reducer.cc",
   "src/compiler/js-inlining-heuristic.cc",
   "src/compiler/js-inlining.cc",
   "src/compiler/js-intrinsic-lowering.cc",

infra/testing/builders.pyl

@@ -361,7 +361,6 @@
       {'name': 'v8testing', 'variant': 'stress_instruction_scheduling'},
       {'name': 'v8testing', 'variant': 'stress_concurrent_allocation'},
       {'name': 'v8testing', 'variant': 'stress_concurrent_inlining'},
-      {'name': 'v8testing', 'variant': 'no_concurrent_inlining'},
     ],
   },
   'v8_linux64_dict_tracking_dbg_ng_triggered': {
@@ -474,7 +473,6 @@
       {'name': 'v8testing', 'variant': 'extra'},
       {'name': 'v8testing', 'variant': 'no_lfa'},
       {'name': 'v8testing', 'variant': 'stress_instruction_scheduling'},
-      {'name': 'v8testing', 'variant': 'no_concurrent_inlining'},
     ],
   },
   'v8_linux64_perfetto_dbg_ng_triggered': {
@@ -520,7 +518,6 @@
       {'name': 'v8testing', 'variant': 'no_lfa'},
       {'name': 'v8testing', 'variant': 'slow_path'},
       {'name': 'v8testing', 'variant': 'stress_instruction_scheduling'},
-      {'name': 'v8testing', 'variant': 'no_concurrent_inlining'},
     ],
   },
   'v8_linux64_tsan_rel_ng_triggered': {
@@ -1153,7 +1150,6 @@
       {'name': 'v8testing', 'variant': 'minor_mc'},
       {'name': 'v8testing', 'variant': 'no_lfa'},
       {'name': 'v8testing', 'variant': 'stress_instruction_scheduling'},
-      {'name': 'v8testing', 'variant': 'no_concurrent_inlining'},
       # Noavx.
       {
         'name': 'mozilla',
@@ -1215,7 +1211,6 @@
       {'name': 'v8testing', 'variant': 'stress_instruction_scheduling'},
       {'name': 'v8testing', 'variant': 'stress_concurrent_allocation'},
       {'name': 'v8testing', 'variant': 'stress_concurrent_inlining'},
-      {'name': 'v8testing', 'variant': 'no_concurrent_inlining'},
       # Noavx.
       {
         'name': 'mozilla',

src/codegen/optimized-compilation-info.cc

@@ -66,10 +66,6 @@ OptimizedCompilationInfo::OptimizedCompilationInfo(
 void OptimizedCompilationInfo::ConfigureFlags() {
   if (FLAG_turbo_inline_js_wasm_calls) set_inline_js_wasm_calls();
 
-  if (IsTurboprop() || FLAG_concurrent_inlining) {
-    set_concurrent_inlining();
-  }
-
   switch (code_kind_) {
     case CodeKind::TURBOFAN:
       if (FLAG_function_context_specialization) {

src/codegen/optimized-compilation-info.h

@@ -68,9 +68,8 @@ class V8_EXPORT_PRIVATE OptimizedCompilationInfo final {
   V(TraceTurboAllocation, trace_turbo_allocation, 14)                \
   V(TraceHeapBroker, trace_heap_broker, 15)                          \
   V(WasmRuntimeExceptionSupport, wasm_runtime_exception_support, 16) \
-  V(ConcurrentInlining, concurrent_inlining, 17)                     \
-  V(DiscardResultForTesting, discard_result_for_testing, 18)         \
-  V(InlineJSWasmCalls, inline_js_wasm_calls, 19)
+  V(DiscardResultForTesting, discard_result_for_testing, 17)         \
+  V(InlineJSWasmCalls, inline_js_wasm_calls, 18)
 
   enum Flag {
 #define DEF_ENUM(Camel, Lower, Bit) k##Camel = 1 << Bit,

src/compiler/access-info.cc

@@ -730,8 +730,7 @@ bool AccessInfoFactory::TryLoadPropertyDetails(
     }
   } else {
     DescriptorArray descriptors = *map.instance_descriptors().object();
-    *index_out = descriptors.Search(*name.object(), *map.object(),
-                                    broker()->is_concurrent_inlining());
+    *index_out = descriptors.Search(*name.object(), *map.object(), true);
     if (index_out->is_found()) {
       *details_out = descriptors.GetDetails(*index_out);
     }
@@ -744,10 +743,8 @@ PropertyAccessInfo AccessInfoFactory::ComputePropertyAccessInfo(
     MapRef map, NameRef name, AccessMode access_mode) const {
   CHECK(name.IsUniqueName());
 
-  // Dictionary property const tracking is unsupported when concurrent inlining
-  // is enabled.
-  CHECK_IMPLIES(V8_DICT_PROPERTY_CONST_TRACKING_BOOL,
-                !broker()->is_concurrent_inlining());
+  // Dictionary property const tracking is unsupported with concurrent inlining.
+  CHECK(!V8_DICT_PROPERTY_CONST_TRACKING_BOOL);
 
   JSHeapBroker::MapUpdaterGuardIfNeeded mumd_scope(broker());
 
@@ -911,12 +908,6 @@ PropertyAccessInfo AccessInfoFactory::ComputePropertyAccessInfo(
     }
 
     // Walk up the prototype chain.
-    if (!broker()->is_concurrent_inlining()) {
-      if (!map.TrySerializePrototype(NotConcurrentInliningTag{broker()})) {
-        return Invalid();
-      }
-    }
-
     // Load the map's prototype's map to guarantee that every time we use it,
     // we use the same Map.
     base::Optional<HeapObjectRef> prototype = map.prototype();
@@ -1129,8 +1120,7 @@ PropertyAccessInfo AccessInfoFactory::LookupTransition(
     PropertyAttributes attrs) const {
   // Check if the {map} has a data transition with the given {name}.
   Map transition =
-      TransitionsAccessor(isolate(), map.object(),
-                          broker()->is_concurrent_inlining())
+      TransitionsAccessor(isolate(), map.object(), true)
           .SearchTransition(*name.object(), PropertyKind::kData, attrs);
   if (transition.is_null()) return Invalid();
 
@@ -1202,11 +1192,6 @@ PropertyAccessInfo AccessInfoFactory::LookupTransition(
 
   unrecorded_dependencies.push_back(
       dependencies()->TransitionDependencyOffTheRecord(transition_map));
-  if (!broker()->is_concurrent_inlining()) {
-    transition_map.SerializeBackPointer(
-        NotConcurrentInliningTag{broker()});  // For BuildPropertyStore.
-  }
-
   // Transitioning stores *may* store to const fields. The resulting
   // DataConstant access infos can be distinguished from later, i.e. redundant,
   // stores to the same constant field by the presence of a transition map.

src/compiler/compilation-dependencies.cc

@@ -1112,9 +1112,6 @@ void CompilationDependencies::DependOnElementsKind(
 
 void CompilationDependencies::DependOnOwnConstantElement(
     const JSObjectRef& holder, uint32_t index, const ObjectRef& element) {
-  // Only valid if the holder can use direct reads, since validation uses
-  // GetOwnConstantElementFromHeap.
-  DCHECK(holder.should_access_heap() || broker_->is_concurrent_inlining());
   RecordDependency(
       zone_->New<OwnConstantElementDependency>(holder, index, element));
 }
@@ -1286,7 +1283,6 @@ void CompilationDependencies::DependOnElementsKinds(
 
 void CompilationDependencies::DependOnConsistentJSFunctionView(
     const JSFunctionRef& function) {
-  DCHECK(broker_->is_concurrent_inlining());
   RecordDependency(zone_->New<ConsistentJSFunctionViewDependency>(function));
 }
 

src/compiler/heap-refs.h

@@ -59,13 +59,6 @@ inline bool IsAnyStore(AccessMode mode) {
   return mode == AccessMode::kStore || mode == AccessMode::kStoreInLiteral;
 }
 
-// Clarifies in function signatures that a method may only be called when
-// concurrent inlining is disabled.
-class NotConcurrentInliningTag final {
- public:
-  explicit NotConcurrentInliningTag(JSHeapBroker* broker);
-};
-
 enum class OddballType : uint8_t {
   kNone,     // Not an Oddball.
   kBoolean,  // True or False.
@@ -424,13 +417,9 @@ class JSObjectRef : public JSReceiverRef {
   // relaxed read. This is to ease the transition to unserialized (or
   // background-serialized) elements.
   base::Optional<FixedArrayBaseRef> elements(RelaxedLoadTag) const;
-  void SerializeElements(NotConcurrentInliningTag tag);
   bool IsElementsTenured(const FixedArrayBaseRef& elements);
 
-  void SerializeObjectCreateMap(NotConcurrentInliningTag tag);
   base::Optional<MapRef> GetObjectCreateMap() const;
-
-  void SerializeAsBoilerplateRecursive(NotConcurrentInliningTag tag);
 };
 
 class JSDataViewRef : public JSObjectRef {
@@ -489,8 +478,6 @@ class RegExpBoilerplateDescriptionRef : public HeapObjectRef {
 
   Handle<RegExpBoilerplateDescription> object() const;
 
-  void Serialize(NotConcurrentInliningTag tag);
-
   FixedArrayRef data() const;
   StringRef source() const;
   int flags() const;
@@ -577,8 +564,6 @@ class NativeContextRef : public ContextRef {
 
   Handle<NativeContext> object() const;
 
-  void Serialize(NotConcurrentInliningTag tag);
-
 #define DECL_ACCESSOR(type, name) type##Ref name() const;
   BROKER_NATIVE_CONTEXT_FIELDS(DECL_ACCESSOR)
 #undef DECL_ACCESSOR
@@ -662,8 +647,6 @@ class AllocationSiteRef : public HeapObjectRef {
   AllocationType GetAllocationType() const;
   ObjectRef nested_site() const;
 
-  void SerializeRecursive(NotConcurrentInliningTag tag);
-
   base::Optional<JSObjectRef> boilerplate() const;
   ElementsKind GetElementsKind() const;
   bool CanInlineCall() const;
@@ -725,17 +708,10 @@ class V8_EXPORT_PRIVATE MapRef : public HeapObjectRef {
   INSTANCE_TYPE_CHECKERS(DEF_TESTER)
 #undef DEF_TESTER
 
-  void SerializeBackPointer(NotConcurrentInliningTag tag);
   HeapObjectRef GetBackPointer() const;
 
-  void SerializePrototype(NotConcurrentInliningTag tag);
-  // TODO(neis): We should be able to remove TrySerializePrototype once
-  // concurrent-inlining is always on. Then we can also change the return type
-  // of prototype() back to HeapObjectRef.
-  bool TrySerializePrototype(NotConcurrentInliningTag tag);
   base::Optional<HeapObjectRef> prototype() const;
 
-  void SerializeForElementStore(NotConcurrentInliningTag tag);
   bool HasOnlyStablePrototypesWithFastElements(
       ZoneVector<MapRef>* prototype_maps);
 

src/compiler/js-heap-broker.cc

@@ -43,8 +43,7 @@ void JSHeapBroker::IncrementTracingIndentation() { ++trace_indentation_; }
 void JSHeapBroker::DecrementTracingIndentation() { --trace_indentation_; }
 
 JSHeapBroker::JSHeapBroker(Isolate* isolate, Zone* broker_zone,
-                           bool tracing_enabled, bool is_concurrent_inlining,
-                           CodeKind code_kind)
+                           bool tracing_enabled, CodeKind code_kind)
     : isolate_(isolate),
 #if V8_COMPRESS_POINTERS
       cage_base_(isolate),
@@ -55,7 +54,6 @@ JSHeapBroker::JSHeapBroker(Isolate* isolate, Zone* broker_zone,
       root_index_map_(isolate),
       array_and_object_prototypes_(zone()),
       tracing_enabled_(tracing_enabled),
-      is_concurrent_inlining_(is_concurrent_inlining),
       code_kind_(code_kind),
       feedback_(zone()),
       property_access_infos_(zone()),
@@ -710,9 +708,6 @@ ProcessedFeedback const& JSHeapBroker::ReadFeedbackForArrayOrObjectLiteral(
 
   AllocationSiteRef site =
       MakeRefAssumeMemoryFence(this, AllocationSite::cast(object));
-  if (!is_concurrent_inlining() && site.PointsToLiteral()) {
-    site.SerializeRecursive(NotConcurrentInliningTag{this});
-  }
   return *zone()->New<LiteralFeedback>(site, nexus.kind());
 }
 
@@ -728,9 +723,6 @@ ProcessedFeedback const& JSHeapBroker::ReadFeedbackForRegExpLiteral(
 
   RegExpBoilerplateDescriptionRef boilerplate = MakeRefAssumeMemoryFence(
       this, RegExpBoilerplateDescription::cast(object));
-  if (!is_concurrent_inlining()) {
-    boilerplate.Serialize(NotConcurrentInliningTag{this});
-  }
   return *zone()->New<RegExpLiteralFeedback>(boilerplate, nexus.kind());
 }
 
@@ -971,12 +963,10 @@ PropertyAccessInfo JSHeapBroker::GetPropertyAccessInfo(
   AccessInfoFactory factory(this, dependencies, zone());
   PropertyAccessInfo access_info =
       factory.ComputePropertyAccessInfo(map, name, access_mode);
-  if (is_concurrent_inlining_) {
-    TRACE(this, "Storing PropertyAccessInfo for "
-                    << access_mode << " of property " << name << " on map "
-                    << map);
-    property_access_infos_.insert({target, access_info});
-  }
+  TRACE(this, "Storing PropertyAccessInfo for "
+                  << access_mode << " of property " << name << " on map "
+                  << map);
+  property_access_infos_.insert({target, access_info});
   return access_info;
 }
 
@@ -989,16 +979,16 @@ MinimorphicLoadPropertyAccessInfo JSHeapBroker::GetPropertyAccessInfo(
   AccessInfoFactory factory(this, nullptr, zone());
   MinimorphicLoadPropertyAccessInfo access_info =
       factory.ComputePropertyAccessInfo(feedback);
-  if (is_concurrent_inlining_) {
-    // We can assume a memory fence on {source.vector} because in production,
-    // the vector has already passed the gc predicate. Unit tests create
-    // FeedbackSource objects directly from handles, but they run on
-    // the main thread.
-    TRACE(this, "Storing MinimorphicLoadPropertyAccessInfo for "
-                    << source.index() << "  "
-                    << MakeRefAssumeMemoryFence<Object>(this, source.vector));
-    minimorphic_property_access_infos_.insert({source, access_info});
-  }
+
+  // We can assume a memory fence on {source.vector} because in production,
+  // the vector has already passed the gc predicate. Unit tests create
+  // FeedbackSource objects directly from handles, but they run on
+  // the main thread.
+  TRACE(this, "Storing MinimorphicLoadPropertyAccessInfo for "
+                  << source.index() << "  "
+                  << MakeRefAssumeMemoryFence<Object>(this, source.vector));
+  minimorphic_property_access_infos_.insert({source, access_info});
+
   return access_info;
 }
 

src/compiler/js-heap-broker.h

@@ -94,12 +94,12 @@ DEFINE_OPERATORS_FOR_FLAGS(GetOrCreateDataFlags)
 class V8_EXPORT_PRIVATE JSHeapBroker {
  public:
   JSHeapBroker(Isolate* isolate, Zone* broker_zone, bool tracing_enabled,
-               bool is_concurrent_inlining, CodeKind code_kind);
+               CodeKind code_kind);
 
   // For use only in tests, sets default values for some arguments. Avoids
   // churn when new flags are added.
   JSHeapBroker(Isolate* isolate, Zone* broker_zone)
-      : JSHeapBroker(isolate, broker_zone, FLAG_trace_heap_broker, false,
+      : JSHeapBroker(isolate, broker_zone, FLAG_trace_heap_broker,
                      CodeKind::TURBOFAN) {}
 
   ~JSHeapBroker();
@@ -127,7 +127,6 @@ class V8_EXPORT_PRIVATE JSHeapBroker {
 
   Zone* zone() const { return zone_; }
   bool tracing_enabled() const { return tracing_enabled_; }
-  bool is_concurrent_inlining() const { return is_concurrent_inlining_; }
   bool is_turboprop() const { return code_kind_ == CodeKind::TURBOPROP; }
 
   NexusConfig feedback_nexus_config() const {
@@ -436,7 +435,6 @@ class V8_EXPORT_PRIVATE JSHeapBroker {
       array_and_object_prototypes_;
   BrokerMode mode_ = kDisabled;
   bool const tracing_enabled_;
-  bool const is_concurrent_inlining_;
   CodeKind const code_kind_;
   std::unique_ptr<PersistentHandles> ph_;
   LocalIsolate* local_isolate_ = nullptr;

src/compiler/js-heap-copy-reducer.cc

@@ -1,226 +0,0 @@
-// Copyright 2018 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/compiler/js-heap-copy-reducer.h"
-
-#include "src/compiler/common-operator.h"
-#include "src/compiler/js-heap-broker.h"
-#include "src/compiler/js-operator.h"
-#include "src/compiler/node-properties.h"
-#include "src/compiler/simplified-operator.h"
-#include "src/heap/factory-inl.h"
-#include "src/objects/map.h"
-#include "src/objects/scope-info.h"
-#include "src/objects/template-objects.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-// In the functions below, we call the ObjectRef (or subclass) constructor in
-// order to trigger serialization if not yet done.
-
-JSHeapCopyReducer::JSHeapCopyReducer(JSHeapBroker* broker) : broker_(broker) {}
-
-JSHeapBroker* JSHeapCopyReducer::broker() { return broker_; }
-
-Reduction JSHeapCopyReducer::Reduce(Node* node) {
-  switch (node->opcode()) {
-    case IrOpcode::kHeapConstant: {
-      ObjectRef object = MakeRef(broker(), HeapConstantOf(node->op()));
-      if (object.IsJSObject()) {
-        object.AsJSObject().SerializeObjectCreateMap(
-            NotConcurrentInliningTag{broker()});
-      }
-      break;
-    }
-    case IrOpcode::kJSCreateArray: {
-      CreateArrayParametersOf(node->op()).site(broker());
-      break;
-    }
-    case IrOpcode::kJSCreateArguments: {
-      Node* const frame_state = NodeProperties::GetFrameStateInput(node);
-      FrameStateInfo state_info = FrameStateInfoOf(frame_state->op());
-      MakeRef(broker(), state_info.shared_info().ToHandleChecked());
-      break;
-    }
-    case IrOpcode::kJSCreateBlockContext: {
-      USE(ScopeInfoOf(broker(), node->op()));
-      break;
-    }
-    case IrOpcode::kJSCreateBoundFunction: {
-      CreateBoundFunctionParameters const& p =
-          CreateBoundFunctionParametersOf(node->op());
-      p.map(broker());
-      break;
-    }
-    case IrOpcode::kJSCreateCatchContext: {
-      USE(ScopeInfoOf(broker(), node->op()));
-      break;
-    }
-    case IrOpcode::kJSCreateClosure: {
-      CreateClosureParameters const& p = CreateClosureParametersOf(node->op());
-      p.shared_info(broker());
-      p.code(broker());
-      break;
-    }
-    case IrOpcode::kJSCreateEmptyLiteralArray: {
-      FeedbackParameter const& p = FeedbackParameterOf(node->op());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForArrayOrObjectLiteral(p.feedback());
-      }
-      break;
-    }
-    /* Unary ops. */
-    case IrOpcode::kJSBitwiseNot:
-    case IrOpcode::kJSDecrement:
-    case IrOpcode::kJSIncrement:
-    case IrOpcode::kJSNegate: {
-      FeedbackParameter const& p = FeedbackParameterOf(node->op());
-      if (p.feedback().IsValid()) {
-        // Unary ops are treated as binary ops with respect to feedback.
-        broker()->GetFeedbackForBinaryOperation(p.feedback());
-      }
-      break;
-    }
-    /* Binary ops. */
-    case IrOpcode::kJSAdd:
-    case IrOpcode::kJSSubtract:
-    case IrOpcode::kJSMultiply:
-    case IrOpcode::kJSDivide:
-    case IrOpcode::kJSModulus:
-    case IrOpcode::kJSExponentiate:
-    case IrOpcode::kJSBitwiseOr:
-    case IrOpcode::kJSBitwiseXor:
-    case IrOpcode::kJSBitwiseAnd:
-    case IrOpcode::kJSShiftLeft:
-    case IrOpcode::kJSShiftRight:
-    case IrOpcode::kJSShiftRightLogical: {
-      FeedbackParameter const& p = FeedbackParameterOf(node->op());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForBinaryOperation(p.feedback());
-      }
-      break;
-    }
-    /* Compare ops. */
-    case IrOpcode::kJSEqual:
-    case IrOpcode::kJSGreaterThan:
-    case IrOpcode::kJSGreaterThanOrEqual:
-    case IrOpcode::kJSLessThan:
-    case IrOpcode::kJSLessThanOrEqual:
-    case IrOpcode::kJSStrictEqual: {
-      FeedbackParameter const& p = FeedbackParameterOf(node->op());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForCompareOperation(p.feedback());
-      }
-      break;
-    }
-    case IrOpcode::kJSCreateFunctionContext: {
-      CreateFunctionContextParameters const& p =
-          CreateFunctionContextParametersOf(node->op());
-      p.scope_info(broker());
-      break;
-    }
-    case IrOpcode::kJSCreateLiteralArray:
-    case IrOpcode::kJSCreateLiteralObject: {
-      CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForArrayOrObjectLiteral(p.feedback());
-      }
-      break;
-    }
-    case IrOpcode::kJSCreateLiteralRegExp: {
-      CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForRegExpLiteral(p.feedback());
-      }
-      break;
-    }
-    case IrOpcode::kJSGetTemplateObject: {
-      GetTemplateObjectParameters const& p =
-          GetTemplateObjectParametersOf(node->op());
-      p.shared(broker());
-      p.description(broker());
-      broker()->GetFeedbackForTemplateObject(p.feedback());
-      break;
-    }
-    case IrOpcode::kJSCreateWithContext: {
-      USE(ScopeInfoOf(broker(), node->op()));
-      break;
-    }
-    case IrOpcode::kJSLoadNamed: {
-      NamedAccess const& p = NamedAccessOf(node->op());
-      NameRef name = p.name(broker());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForPropertyAccess(p.feedback(), AccessMode::kLoad,
-                                               name);
-      }
-      break;
-    }
-    case IrOpcode::kJSLoadNamedFromSuper: {
-      NamedAccess const& p = NamedAccessOf(node->op());
-      NameRef name = p.name(broker());
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForPropertyAccess(p.feedback(), AccessMode::kLoad,
-                                               name);
-      }
-      break;
-    }
-    case IrOpcode::kJSStoreNamed: {
-      NamedAccess const& p = NamedAccessOf(node->op());
-      p.name(broker());
-      break;
-    }
-    case IrOpcode::kStoreField:
-    case IrOpcode::kLoadField: {
-      FieldAccess access = FieldAccessOf(node->op());
-      Handle<Map> map_handle;
-      if (access.map.ToHandle(&map_handle)) {
-        MakeRef(broker(), map_handle);
-      }
-      Handle<Name> name_handle;
-      if (access.name.ToHandle(&name_handle)) {
-        MakeRef(broker(), name_handle);
-      }
-      break;
-    }
-    case IrOpcode::kMapGuard: {
-      ZoneHandleSet<Map> const& maps = MapGuardMapsOf(node->op());
-      for (Handle<Map> map : maps) {
-        MakeRef(broker(), map);
-      }
-      break;
-    }
-    case IrOpcode::kCheckMaps: {
-      ZoneHandleSet<Map> const& maps = CheckMapsParametersOf(node->op()).maps();
-      for (Handle<Map> map : maps) {
-        MakeRef(broker(), map);
-      }
-      break;
-    }
-    case IrOpcode::kCompareMaps: {
-      ZoneHandleSet<Map> const& maps = CompareMapsParametersOf(node->op());
-      for (Handle<Map> map : maps) {
-        MakeRef(broker(), map);
-      }
-      break;
-    }
-    case IrOpcode::kJSLoadProperty: {
-      PropertyAccess const& p = PropertyAccessOf(node->op());
-      AccessMode access_mode = AccessMode::kLoad;
-      if (p.feedback().IsValid()) {
-        broker()->GetFeedbackForPropertyAccess(p.feedback(), access_mode,
-                                               base::nullopt);
-      }
-      break;
-    }
-    default:
-      break;
-  }
-  return NoChange();
-}
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8

src/compiler/js-heap-copy-reducer.h

@@ -1,38 +0,0 @@
-// Copyright 2018 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_COMPILER_JS_HEAP_COPY_REDUCER_H_
-#define V8_COMPILER_JS_HEAP_COPY_REDUCER_H_
-
-#include "src/compiler/graph-reducer.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class JSHeapBroker;
-
-// The heap copy reducer makes sure that the relevant heap data referenced
-// by handles embedded in the graph is copied to the heap broker.
-// TODO(jarin) This is just a temporary solution until the graph uses only
-// ObjetRef-derived reference to refer to the heap data.
-class V8_EXPORT_PRIVATE JSHeapCopyReducer : public Reducer {
- public:
-  explicit JSHeapCopyReducer(JSHeapBroker* broker);
-
-  const char* reducer_name() const override { return "JSHeapCopyReducer"; }
-
-  Reduction Reduce(Node* node) override;
-
- private:
-  JSHeapBroker* broker();
-
-  JSHeapBroker* broker_;
-};
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_COMPILER_JS_HEAP_COPY_REDUCER_H_

src/compiler/js-inlining.cc

@@ -533,24 +533,18 @@ Reduction JSInliner::ReduceJSCall(Node* node) {
   // always hold true.
   CHECK(shared_info->is_compiled());
 
-  if (info_->source_positions()) {
-    if (broker()->is_concurrent_inlining()) {
-      if (!shared_info->object()->AreSourcePositionsAvailable(
-              broker()->local_isolate_or_isolate())) {
-        // This case is expected to be very rare, since we generate source
-        // positions for all functions when debugging or profiling are turned
-        // on (see Isolate::NeedsDetailedOptimizedCodeLineInfo). Source
-        // positions should only be missing here if there is a race between 1)
-        // enabling/disabling the debugger/profiler, and 2) this compile job.
-        // In that case, we simply don't inline.
-        TRACE("Not inlining " << *shared_info << " into " << outer_shared_info
-                              << " because source positions are missing.");
-        return NoChange();
-      }
-    } else {
-      SharedFunctionInfo::EnsureSourcePositionsAvailable(isolate(),
-                                                         shared_info->object());
-    }
+  if (info_->source_positions() &&
+      !shared_info->object()->AreSourcePositionsAvailable(
+          broker()->local_isolate_or_isolate())) {
+    // This case is expected to be very rare, since we generate source
+    // positions for all functions when debugging or profiling are turned
+    // on (see Isolate::NeedsDetailedOptimizedCodeLineInfo). Source
+    // positions should only be missing here if there is a race between 1)
+    // enabling/disabling the debugger/profiler, and 2) this compile job.
+    // In that case, we simply don't inline.
+    TRACE("Not inlining " << *shared_info << " into " << outer_shared_info
+                          << " because source positions are missing.");
+    return NoChange();
   }
 
   // Determine the target's feedback vector and its context.

src/compiler/pipeline.cc

@@ -49,7 +49,6 @@
 #include "src/compiler/js-create-lowering.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/js-heap-broker.h"
-#include "src/compiler/js-heap-copy-reducer.h"
 #include "src/compiler/js-inlining-heuristic.h"
 #include "src/compiler/js-intrinsic-lowering.h"
 #include "src/compiler/js-native-context-specialization.h"
@@ -157,9 +156,9 @@ class PipelineData {
         instruction_zone_(instruction_zone_scope_.zone()),
         codegen_zone_scope_(zone_stats_, kCodegenZoneName),
         codegen_zone_(codegen_zone_scope_.zone()),
-        broker_(new JSHeapBroker(
-            isolate_, info_->zone(), info_->trace_heap_broker(),
-            info_->concurrent_inlining(), info->code_kind())),
+        broker_(new JSHeapBroker(isolate_, info_->zone(),
+                                 info_->trace_heap_broker(),
+                                 info->code_kind())),
         register_allocation_zone_scope_(zone_stats_,
                                         kRegisterAllocationZoneName),
         register_allocation_zone_(register_allocation_zone_scope_.zone()),
@@ -1200,17 +1199,8 @@ PipelineCompilationJob::Status PipelineCompilationJob::PrepareJobImpl(
 
   pipeline_.InitializeHeapBroker();
 
-  if (!data_.broker()->is_concurrent_inlining()) {
-    if (!pipeline_.CreateGraph()) {
-      CHECK(!isolate->has_pending_exception());
-      return AbortOptimization(BailoutReason::kGraphBuildingFailed);
-    }
-  }
-
-  if (compilation_info()->concurrent_inlining()) {
-    // Serialization may have allocated.
-    isolate->heap()->PublishPendingAllocations();
-  }
+  // Serialization may have allocated.
+  isolate->heap()->PublishPendingAllocations();
 
   return SUCCEEDED;
 }
@@ -1223,10 +1213,8 @@ PipelineCompilationJob::Status PipelineCompilationJob::ExecuteJobImpl(
   LocalIsolateScope local_isolate_scope(data_.broker(), data_.info(),
                                         local_isolate);
 
-  if (data_.broker()->is_concurrent_inlining()) {
-    if (!pipeline_.CreateGraph()) {
-      return AbortOptimization(BailoutReason::kGraphBuildingFailed);
-    }
+  if (!pipeline_.CreateGraph()) {
+    return AbortOptimization(BailoutReason::kGraphBuildingFailed);
   }
 
   // We selectively Unpark inside OptimizeGraph*.
@@ -1514,24 +1502,6 @@ struct HeapBrokerInitializationPhase {
   }
 };
 
-struct CopyMetadataForConcurrentCompilePhase {
-  DECL_MAIN_THREAD_PIPELINE_PHASE_CONSTANTS(SerializeMetadata)
-
-  void Run(PipelineData* data, Zone* temp_zone) {
-    GraphReducer graph_reducer(
-        temp_zone, data->graph(), &data->info()->tick_counter(), data->broker(),
-        data->jsgraph()->Dead(), data->observe_node_manager());
-    JSHeapCopyReducer heap_copy_reducer(data->broker());
-    AddReducer(data, &graph_reducer, &heap_copy_reducer);
-    graph_reducer.ReduceGraph();
-
-    // Some nodes that are no longer in the graph might still be in the cache.
-    NodeVector cached_nodes(temp_zone);
-    data->jsgraph()->GetCachedNodes(&cached_nodes);
-    for (Node* const node : cached_nodes) graph_reducer.ReduceNode(node);
-  }
-};
-
 struct TypedLoweringPhase {
   DECL_PIPELINE_PHASE_CONSTANTS(TypedLowering)
 
@@ -2693,10 +2663,8 @@ void PipelineImpl::InitializeHeapBroker() {
   }
 
   data->broker()->SetTargetNativeContextRef(data->native_context());
-  if (data->broker()->is_concurrent_inlining()) {
-    Run<HeapBrokerInitializationPhase>();
-    data->broker()->StopSerializing();
-  }
+  Run<HeapBrokerInitializationPhase>();
+  data->broker()->StopSerializing();
   data->EndPhaseKind();
 }
 
@@ -2728,15 +2696,6 @@ bool PipelineImpl::CreateGraph() {
     }
   }
 
-  // Run the type-sensitive lowerings and optimizations on the graph.
-  {
-    if (!data->broker()->is_concurrent_inlining()) {
-      Run<HeapBrokerInitializationPhase>();
-      Run<CopyMetadataForConcurrentCompilePhase>();
-      data->broker()->StopSerializing();
-    }
-  }
-
   data->EndPhaseKind();
 
   return true;
@@ -3391,20 +3350,12 @@ MaybeHandle<Code> Pipeline::GenerateCodeForTesting(
     CanonicalHandleScope canonical(isolate, info);
     info->ReopenHandlesInNewHandleScope(isolate);
     pipeline.InitializeHeapBroker();
-    // Emulating the proper pipeline, we call CreateGraph on different places
-    // (i.e before or after creating a LocalIsolateScope) depending on
-    // is_concurrent_inlining.
-    if (!data.broker()->is_concurrent_inlining()) {
-      if (!pipeline.CreateGraph()) return MaybeHandle<Code>();
-    }
   }
 
   {
     LocalIsolateScope local_isolate_scope(data.broker(), info,
                                           isolate->main_thread_local_isolate());
-    if (data.broker()->is_concurrent_inlining()) {
-      if (!pipeline.CreateGraph()) return MaybeHandle<Code>();
-    }
+    if (!pipeline.CreateGraph()) return MaybeHandle<Code>();
     // We selectively Unpark inside OptimizeGraph.
     if (!pipeline.OptimizeGraph(&linkage)) return MaybeHandle<Code>();
 

src/flags/flag-definitions.h

@@ -434,7 +434,6 @@ DEFINE_NEG_IMPLICATION(enable_third_party_heap, inline_new)
 DEFINE_NEG_IMPLICATION(enable_third_party_heap, allocation_site_pretenuring)
 DEFINE_NEG_IMPLICATION(enable_third_party_heap, turbo_allocation_folding)
 DEFINE_NEG_IMPLICATION(enable_third_party_heap, concurrent_recompilation)
-DEFINE_NEG_IMPLICATION(enable_third_party_heap, concurrent_inlining)
 DEFINE_NEG_IMPLICATION(enable_third_party_heap, script_streaming)
 DEFINE_NEG_IMPLICATION(enable_third_party_heap,
                        parallel_compile_tasks_for_eager_toplevel)
@@ -520,7 +519,6 @@ DEFINE_WEAK_VALUE_IMPLICATION(future, write_protect_code_memory, false)
 DEFINE_BOOL_READONLY(dict_property_const_tracking,
                      V8_DICT_PROPERTY_CONST_TRACKING_BOOL,
                      "Use const tracking on dictionary properties")
-DEFINE_NEG_IMPLICATION(dict_property_const_tracking, concurrent_inlining)
 DEFINE_NEG_IMPLICATION(dict_property_const_tracking, turboprop)
 
 // Flags for jitless
@@ -548,7 +546,6 @@ DEFINE_BOOL(assert_types, false,
             "generate runtime type assertions to test the typer")
 // TODO(tebbi): Support allocating types from background thread.
 DEFINE_NEG_IMPLICATION(assert_types, concurrent_recompilation)
-DEFINE_NEG_IMPLICATION(assert_types, concurrent_inlining)
 
 DEFINE_BOOL(trace_compilation_dependencies, false, "trace code dependencies")
 // Depend on --trace-deopt-verbose for reporting dependency invalidations.
@@ -754,12 +751,13 @@ DEFINE_INT(concurrent_recompilation_queue_length, 8,
            "the length of the concurrent compilation queue")
 DEFINE_INT(concurrent_recompilation_delay, 0,
            "artificial compilation delay in ms")
-DEFINE_BOOL(concurrent_inlining, true,
-            "run optimizing compiler's inlining phase on a separate thread")
+// TODO(v8:12142): Remove this flag once all references (chromium feature flag,
+// finch trials, field trial configs) are gone.
+DEFINE_BOOL(concurrent_inlining, true, "deprecated, does nothing")
 DEFINE_BOOL(
     stress_concurrent_inlining, false,
     "create additional concurrent optimization jobs but throw away result")
-DEFINE_IMPLICATION(stress_concurrent_inlining, concurrent_inlining)
+DEFINE_IMPLICATION(stress_concurrent_inlining, concurrent_recompilation)
 DEFINE_NEG_IMPLICATION(stress_concurrent_inlining, lazy_feedback_allocation)
 DEFINE_WEAK_VALUE_IMPLICATION(stress_concurrent_inlining, interrupt_budget,
                               15 * KB)

test/cctest/compiler/test-concurrent-shared-function-info.cc

@@ -92,7 +92,6 @@ class BackgroundCompilationThread final : public v8::base::Thread {
 
 TEST(TestConcurrentSharedFunctionInfo) {
   FlagScope<bool> allow_natives_syntax(&i::FLAG_allow_natives_syntax, true);
-  FlagScope<bool> concurrent_inlining(&i::FLAG_concurrent_inlining, true);
 
   HandleAndZoneScope scope;
   Isolate* isolate = scope.main_isolate();

test/cctest/compiler/test-js-typed-lowering.cc

@@ -6,7 +6,6 @@
 #include "src/compiler/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-heap-broker.h"
-#include "src/compiler/js-heap-copy-reducer.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
@@ -92,8 +91,6 @@ class JSTypedLoweringTester : public HandleAndZoneScope {
   }
 
   Node* reduce(Node* node) {
-    JSHeapCopyReducer heap_copy_reducer(&js_heap_broker);
-    CHECK(!heap_copy_reducer.Reduce(node).Changed());
     JSGraph jsgraph(main_isolate(), &graph, &common, &javascript, &simplified,
                     &machine);
     GraphReducer graph_reducer(main_zone(), &graph, &tick_counter,

test/mjsunit/compiler/bound-functions-serialize.js

@@ -1,9 +1,9 @@
 // Copyright 2019 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+//
+// Flags: --allow-natives-syntax --opt --noalways-opt --noturboprop
 
-// Flags: --allow-natives-syntax --concurrent-inlining
-// Flags: --opt --noalways-opt --noturboprop
 class C {};
 const c = new C;
 const getPrototypeOf = Object.getPrototypeOf;

test/mjsunit/compiler/regress-1225607.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: --interrupt-budget=1024 --concurrent-inlining
+// Flags: --interrupt-budget=1024
 
 const v2 = {};
 const v4 = {a:42};

test/mjsunit/compiler/regress-1227324.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 --concurrent-inlining
+// Flags: --allow-natives-syntax
 
 (function() {
   var use_symbol = {

test/mjsunit/harmony/weakrefs/finalizationregistry-independent-lifetime.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 --noincremental-marking --no-concurrent-inlining
+// Flags: --expose-gc --noincremental-marking --no-concurrent-recompilation
 
 let cleanup_called = false;
 function cleanup(holdings) {

test/mjsunit/regress-1146106.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 --concurrent-inlining --no-use-ic --super-ic
+// Flags: --allow-natives-syntax --no-use-ic --super-ic
 
 class A {
   bar() { }

test/mjsunit/regress/regress-1003730.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 --concurrent-inlining
+// Flags: --allow-natives-syntax
 
 function bar(error) {
   try {

test/mjsunit/regress/regress-1168435.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 --concurrent-inlining
+// Flags: --allow-natives-syntax
 
 function bar() {
   arr = new Array(4);

test/mjsunit/regress/regress-4578.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 --expose-gc --opt --no-concurrent-inlining
+// Flags: --allow-natives-syntax --expose-gc --opt --no-concurrent-recompilation
 // Flags: --no-stress-opt --no-always-opt --no-assert-types
 
 // This weak ref is for checking whether the closure-allocated object o got

test/mjsunit/regress/regress-936077.js

@@ -2,8 +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: --concurrent-inlining --function-context-specialization
+// Flags: --expose-gc --allow-natives-syntax --function-context-specialization
 
 function main() {
   var obj = {};

test/unittests/compiler/graph-unittest.cc

@@ -4,7 +4,6 @@
 
 #include "test/unittests/compiler/graph-unittest.h"
 
-#include "src/compiler/js-heap-copy-reducer.h"
 #include "src/compiler/node-properties.h"
 #include "src/heap/factory.h"
 #include "src/objects/objects-inl.h"  // TODO(everyone): Make typer.h IWYU compliant.

test/unittests/compiler/js-typed-lowering-unittest.cc

@@ -8,7 +8,6 @@
 #include "src/compiler/access-builder.h"
 #include "src/compiler/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
-#include "src/compiler/js-heap-copy-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
@@ -46,8 +45,6 @@ class JSTypedLoweringTest : public TypedGraphTest {
 
  protected:
   Reduction Reduce(Node* node) {
-    JSHeapCopyReducer heap_copy_reducer(broker());
-    CHECK(!heap_copy_reducer.Reduce(node).Changed());
     MachineOperatorBuilder machine(zone());
     SimplifiedOperatorBuilder simplified(zone());
     JSGraph jsgraph(isolate(), graph(), common(), javascript(), &simplified,

tools/testrunner/local/variants.py

@@ -17,8 +17,6 @@ ALL_VARIANT_FLAGS = {
   "sparkplug": [["--sparkplug"]],
   "always_sparkplug": [[ "--always-sparkplug", "--sparkplug"]],
   "minor_mc": [["--minor-mc"]],
-  "no_concurrent_inlining":  [["--no-concurrent-inlining",
-                               "--no-stress-concurrent-inlining"]],
   "no_lfa": [["--no-lazy-feedback-allocation"]],
   # No optimization means disable all optimizations. OptimizeFunctionOnNextCall
   # would not force optimization too. It turns into a Nop. Please see
@@ -31,8 +29,7 @@ ALL_VARIANT_FLAGS = {
   "stress": [["--stress-opt", "--no-liftoff", "--stress-lazy-source-positions",
               "--no-wasm-generic-wrapper"]],
   "stress_concurrent_allocation": [["--stress-concurrent-allocation"]],
-  "stress_concurrent_inlining": [["--stress-concurrent-inlining",
-                                  "--concurrent-inlining"]],
+  "stress_concurrent_inlining": [["--stress-concurrent-inlining"]],
   "stress_js_bg_compile_wasm_code_gc": [["--stress-background-compile",
                                          "--stress-wasm-code-gc"]],
   "stress_incremental_marking": [["--stress-incremental-marking"]],
@@ -62,7 +59,8 @@ INCOMPATIBLE_FLAGS_PER_VARIANT = {
   "stress_concurrent_allocation": ["--single-threaded-gc", "--predictable"],
   "stress_concurrent_inlining": ["--single-threaded", "--predictable",
                                  "--turboprop", "--lazy-feedback-allocation",
-                                 "--assert-types"],
+                                 "--assert-types",
+                                 "--no-concurrent-recompilation"],
   "turboprop": ["--stress_concurrent_inlining"],
   # The fast API tests initialize an embedder object that never needs to be
   # serialized to the snapshot, so we don't have a
@@ -82,7 +80,7 @@ INCOMPATIBLE_FLAGS_PER_VARIANT = {
   # There is a negative implication: --perf-prof disables
   # --wasm-write-protect-code-memory.
   "wasm_write_protect_code": ["--perf-prof"],
-  "assert_types": ["--concurrent-recompilation", "--concurrent-inlining", "--stress_concurrent_inlining", "--no-assert-types"],
+  "assert_types": ["--concurrent-recompilation", "--stress_concurrent_inlining", "--no-assert-types"],
 }
 
 # Flags that lead to a contradiction under certain build variables.
@@ -100,7 +98,6 @@ INCOMPATIBLE_FLAGS_PER_BUILD_VARIABLE = {
                   "--stress-concurrent-allocation",
                   "--stress-concurrent-inlining"],
   "dict_property_const_tracking": [
-                  "--concurrent-inlining",
                   "--turboprop",
                   "--stress-concurrent-inlining"],
 }