[protectors] Cleanup protector statics on isolate

Removes the static protector values from isolate now that they are
no longer needed.

This is the final cl in the migration effort.

Bug: v8:9463
Change-Id: I2127ef6c8a0cdaf0ccf28aed12539335ef985704
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1827455Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Commit-Queue: Joshua Litt <joshualitt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64068}

src/builtins/builtins-call-gen.cc

@@ -9,6 +9,7 @@
 #include "src/codegen/macro-assembler.h"
 #include "src/common/globals.h"
 #include "src/execution/isolate.h"
+#include "src/execution/protectors.h"
 #include "src/objects/api-callbacks.h"
 #include "src/objects/arguments.h"
 #include "src/objects/property-cell.h"
@@ -294,7 +295,7 @@ void CallOrConstructBuiltinsAssembler::CallOrConstructWithSpread(
   TNode<PropertyCell> protector_cell = ArrayIteratorProtectorConstant();
   GotoIf(
       TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Isolate::kProtectorInvalid)),
+                  SmiConstant(Protectors::kProtectorInvalid)),
       &if_generic);
   {
     // The fast-path accesses the {spread} elements directly.

src/builtins/builtins-collections-gen.cc

@@ -8,6 +8,7 @@
 #include "src/builtins/builtins-iterator-gen.h"
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/codegen/code-stub-assembler.h"
+#include "src/execution/protectors.h"
 #include "src/heap/factory-inl.h"
 #include "src/heap/heap-inl.h"
 #include "src/objects/hash-table-inl.h"
@@ -952,7 +953,7 @@ void CollectionsBuiltinsAssembler::BranchIfMapIteratorProtectorValid(
   DCHECK(isolate()->heap()->map_iterator_protector().IsPropertyCell());
   Branch(
       TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Isolate::kProtectorValid)),
+                  SmiConstant(Protectors::kProtectorValid)),
       if_true, if_false);
 }
 
@@ -1011,7 +1012,7 @@ void CollectionsBuiltinsAssembler::BranchIfSetIteratorProtectorValid(
   DCHECK(isolate()->heap()->set_iterator_protector().IsPropertyCell());
   Branch(
       TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Isolate::kProtectorValid)),
+                  SmiConstant(Protectors::kProtectorValid)),
       if_true, if_false);
 }
 

src/builtins/builtins-string-gen.cc

@@ -8,6 +8,7 @@
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/codegen/code-factory.h"
+#include "src/execution/protectors.h"
 #include "src/heap/factory-inl.h"
 #include "src/heap/heap-inl.h"
 #include "src/logging/counters.h"
@@ -2120,7 +2121,7 @@ void StringBuiltinsAssembler::BranchIfStringPrimitiveWithNoCustomIteration(
   DCHECK(isolate()->heap()->string_iterator_protector().IsPropertyCell());
   Branch(
       TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Isolate::kProtectorValid)),
+                  SmiConstant(Protectors::kProtectorValid)),
       if_true, if_false);
 }
 

src/builtins/builtins-typed-array-gen.cc

@@ -8,6 +8,7 @@
 #include "src/builtins/builtins-utils-gen.h"
 #include "src/builtins/builtins.h"
 #include "src/builtins/growable-fixed-array-gen.h"
+#include "src/execution/protectors.h"
 #include "src/handles/handles-inl.h"
 #include "src/heap/factory-inl.h"
 
@@ -932,7 +933,7 @@ TF_BUILTIN(TypedArrayFrom, TypedArrayBuiltinsAssembler) {
     TNode<PropertyCell> protector_cell = ArrayIteratorProtectorConstant();
     GotoIfNot(
         TaggedEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                    SmiConstant(Isolate::kProtectorValid)),
+                    SmiConstant(Protectors::kProtectorValid)),
         &check_iterator);
 
     // Source is a TypedArray with unmodified iterator behavior. Use the

src/codegen/code-stub-assembler.cc

@@ -11,6 +11,7 @@
 #include "src/common/globals.h"
 #include "src/execution/frames-inl.h"
 #include "src/execution/frames.h"
+#include "src/execution/protectors.h"
 #include "src/heap/heap-inl.h"  // For Page/MemoryChunk. TODO(jkummerow): Drop.
 #include "src/logging/counters.h"
 #include "src/objects/api-callbacks.h"
@@ -6023,42 +6024,42 @@ TNode<BoolT> CodeStubAssembler::IsUndetectableMap(SloppyTNode<Map> map) {
 }
 
 TNode<BoolT> CodeStubAssembler::IsNoElementsProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = NoElementsProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsArrayIteratorProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = ArrayIteratorProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsPromiseResolveProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = PromiseResolveProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsPromiseThenProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = PromiseThenProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsArraySpeciesProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = ArraySpeciesProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsTypedArraySpeciesProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = TypedArraySpeciesProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);
@@ -6069,12 +6070,12 @@ TNode<BoolT> CodeStubAssembler::IsRegExpSpeciesProtectorCellInvalid(
   TNode<PropertyCell> cell = CAST(LoadContextElement(
       native_context, Context::REGEXP_SPECIES_PROTECTOR_INDEX));
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   return TaggedEqual(cell_value, invalid);
 }
 
 TNode<BoolT> CodeStubAssembler::IsPromiseSpeciesProtectorCellInvalid() {
-  TNode<Smi> invalid = SmiConstant(Isolate::kProtectorInvalid);
+  TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
   TNode<PropertyCell> cell = PromiseSpeciesProtectorConstant();
   TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
   return TaggedEqual(cell_value, invalid);

src/compiler/compilation-dependencies.cc

@@ -5,6 +5,7 @@
 #include "src/compiler/compilation-dependencies.h"
 
 #include "src/compiler/compilation-dependency.h"
+#include "src/execution/protectors.h"
 #include "src/handles/handles-inl.h"
 #include "src/objects/allocation-site-inl.h"
 #include "src/objects/objects-inl.h"
@@ -282,12 +283,12 @@ class GlobalPropertyDependency final : public CompilationDependency {
 class ProtectorDependency final : public CompilationDependency {
  public:
   explicit ProtectorDependency(const PropertyCellRef& cell) : cell_(cell) {
-    DCHECK_EQ(cell_.value().AsSmi(), Isolate::kProtectorValid);
+    DCHECK_EQ(cell_.value().AsSmi(), Protectors::kProtectorValid);
   }
 
   bool IsValid() const override {
     Handle<PropertyCell> cell = cell_.object();
-    return cell->value() == Smi::FromInt(Isolate::kProtectorValid);
+    return cell->value() == Smi::FromInt(Protectors::kProtectorValid);
   }
 
   void Install(const MaybeObjectHandle& code) const override {
@@ -444,7 +445,7 @@ void CompilationDependencies::DependOnGlobalProperty(
 }
 
 bool CompilationDependencies::DependOnProtector(const PropertyCellRef& cell) {
-  if (cell.value().AsSmi() != Isolate::kProtectorValid) return false;
+  if (cell.value().AsSmi() != Protectors::kProtectorValid) return false;
   RecordDependency(new (zone_) ProtectorDependency(cell));
   return true;
 }

src/compiler/js-create-lowering.cc

@@ -18,6 +18,7 @@
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/state-values-utils.h"
+#include "src/execution/protectors.h"
 #include "src/objects/arguments.h"
 #include "src/objects/hash-table-inl.h"
 #include "src/objects/heap-number.h"
@@ -645,8 +646,8 @@ Reduction JSCreateLowering::ReduceJSCreateArray(Node* node) {
   } else {
     PropertyCellRef array_constructor_protector(
         broker(), factory()->array_constructor_protector());
-    can_inline_call =
-        array_constructor_protector.value().AsSmi() == Isolate::kProtectorValid;
+    can_inline_call = array_constructor_protector.value().AsSmi() ==
+                      Protectors::kProtectorValid;
   }
 
   if (arity == 0) {

src/compiler/js-typed-lowering.cc

@@ -17,6 +17,7 @@
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/type-cache.h"
 #include "src/compiler/types.h"
+#include "src/execution/protectors.h"
 #include "src/objects/js-generator.h"
 #include "src/objects/module-inl.h"
 #include "src/objects/objects-inl.h"
@@ -569,7 +570,8 @@ Reduction JSTypedLowering::ReduceJSAdd(Node* node) {
 
     PropertyCellRef string_length_protector(
         broker(), factory()->string_length_protector());
-    if (string_length_protector.value().AsSmi() == Isolate::kProtectorValid) {
+    if (string_length_protector.value().AsSmi() ==
+        Protectors::kProtectorValid) {
       // We can just deoptimize if the {length} is out-of-bounds. Besides
       // generating a shorter code sequence than the version below, this
       // has the additional benefit of not holding on to the lazy {frame_state}

src/execution/isolate.h

@@ -1163,9 +1163,6 @@ class Isolate final : private HiddenFactory {
 
 #endif  // V8_INTL_SUPPORT
 
-  static const int kProtectorValid = 1;
-  static const int kProtectorInvalid = 0;
-
   bool IsArrayOrObjectOrStringPrototype(Object object);
 
   // On intent to set an element in object, make sure that appropriate

src/heap/setup-heap-internal.cc

@@ -7,6 +7,7 @@
 #include "src/builtins/accessors.h"
 #include "src/codegen/compilation-cache.h"
 #include "src/execution/isolate.h"
+#include "src/execution/protectors.h"
 #include "src/heap/factory.h"
 #include "src/heap/heap-inl.h"
 #include "src/ic/handler-configuration.h"
@@ -850,105 +851,105 @@ void Heap::CreateInitialObjects() {
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_array_constructor_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_no_elements_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_array_iterator_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_map_iterator_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_set_iterator_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_is_concat_spreadable_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_array_species_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_typed_array_species_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_promise_species_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_string_iterator_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_string_length_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_array_buffer_detaching_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_promise_hook_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_promise_resolve_protector(*cell);
   }
 
   {
     Handle<PropertyCell> cell =
         factory->NewPropertyCell(factory->empty_string());
-    cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+    cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
     set_promise_then_protector(*cell);
   }
 

src/init/bootstrapper.cc

@@ -12,6 +12,7 @@
 #include "src/debug/debug.h"
 #include "src/execution/isolate-inl.h"
 #include "src/execution/microtask-queue.h"
+#include "src/execution/protectors.h"
 #include "src/extensions/cputracemark-extension.h"
 #include "src/extensions/externalize-string-extension.h"
 #include "src/extensions/free-buffer-extension.h"
@@ -2642,7 +2643,7 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
     {
       Handle<PropertyCell> cell =
           factory->NewPropertyCell(factory->empty_string());
-      cell->set_value(Smi::FromInt(Isolate::kProtectorValid));
+      cell->set_value(Smi::FromInt(Protectors::kProtectorValid));
       native_context()->set_regexp_species_protector(*cell);
     }