Add map-based read barrier to WeakCell

src/hydrogen-instructions.h

 // Copyright 2012 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_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include <cstring>
 #include <iosfwd>
 
@@ skipping 6032 matching lines @@
   inline bool immutable() const {
     return ImmutableField::decode(value_);
   }
 
   // Returns true if access is being made to an in-object property that
   // was already added to the object.
   inline bool existing_inobject_property() const {
     return ExistingInobjectPropertyField::decode(value_);
   }
 
+  inline bool read_barrier() const { return ReadBarrierField::decode(value_); }
+
   inline HObjectAccess WithRepresentation(Representation representation) {
     return HObjectAccess(portion(), offset(), representation, name(),
                          immutable(), existing_inobject_property());
   }
 
   static HObjectAccess ForHeapNumberValue() {
     return HObjectAccess(
         kDouble, HeapNumber::kValueOffset, Representation::Double());
   }
 
@@ skipping 146 matching lines @@
   static HObjectAccess ForMapInstanceTypeAndBitField() {
     STATIC_ASSERT((Map::kInstanceTypeAndBitFieldOffset & 1) == 0);
     // Ensure the two fields share one 16-bit word, endian-independent.
     STATIC_ASSERT((Map::kBitFieldOffset & ~1) ==
                   (Map::kInstanceTypeOffset & ~1));
     return HObjectAccess(kInobject,
                          Map::kInstanceTypeAndBitFieldOffset,
                          Representation::UInteger16());
   }
 
-  static HObjectAccess ForPropertyCellValue() {
-    return HObjectAccess(kInobject, PropertyCell::kValueOffset);
-  }
-
-  static HObjectAccess ForCellValue() {
-    return HObjectAccess(kInobject, Cell::kValueOffset);
-  }
-
   static HObjectAccess ForWeakCellValue() {
-    return HObjectAccess(kInobject, WeakCell::kValueOffset);
+    return HObjectAccess(
+        kInobject, WeakCell::kValueOffsetDontForgetTheReadBarrier,
+        Representation::Tagged(), Handle<String>::null(), false, true, true);
   }
 
   static HObjectAccess ForWeakCellNext() {
     return HObjectAccess(kInobject, WeakCell::kNextOffset);
   }
 
+  // This version of the weak cell value does not trigger the read barrier.
+  // This means that for correctness you can only use the value for an
+  // immediate equality comparison, typically a map check. The GC is not
+  // allowed to see the value eg through a spill to the stack.
+  // TODO(erikcorry): When the SATB collector is actually running these
+  // need to be marked as untagged data when they are spilled to the stack.
+  static HObjectAccess ForWeakCellValueComparison() {
+    return HObjectAccess(
+        kInobject, WeakCell::kValueOffsetDontForgetTheReadBarrier,
+        Representation::Tagged(), Handle<String>::null(), false, true, false);
+  }
+
   static HObjectAccess ForAllocationMementoSite() {
     return HObjectAccess(kInobject, AllocationMemento::kAllocationSiteOffset);
   }
 
   static HObjectAccess ForCounter() {
     return HObjectAccess(kExternalMemory, 0, Representation::Integer32(),
                          Handle<String>::null(), false, false);
   }
 
   static HObjectAccess ForExternalUInteger8() {
@@ skipping 151 matching lines @@
     kDouble,           // some double field
     kInobject,         // some other in-object field
     kExternalMemory    // some field in external memory
   };
 
   HObjectAccess() : value_(0) {}
 
   HObjectAccess(Portion portion, int offset,
                 Representation representation = Representation::Tagged(),
                 Handle<String> name = Handle<String>::null(),
-                bool immutable = false,
-                bool existing_inobject_property = true)
-    : value_(PortionField::encode(portion) |
-             RepresentationField::encode(representation.kind()) |
-             ImmutableField::encode(immutable ? 1 : 0) |
-             ExistingInobjectPropertyField::encode(
-                 existing_inobject_property ? 1 : 0) |
-             OffsetField::encode(offset)),
-      name_(name) {
+                bool immutable = false, bool existing_inobject_property = true,
+                bool read_barrier = false)
+      : value_(PortionField::encode(portion) |
+               RepresentationField::encode(representation.kind()) |
+               ImmutableField::encode(immutable ? 1 : 0) |
+               ExistingInobjectPropertyField::encode(
+                   existing_inobject_property ? 1 : 0) |
+               ReadBarrierField::encode(read_barrier ? 1 : 0) |
+               OffsetField::encode(offset)),
+        name_(name) {
     // assert that the fields decode correctly
     DCHECK(this->offset() == offset);
     DCHECK(this->portion() == portion);
     DCHECK(this->immutable() == immutable);
     DCHECK(this->existing_inobject_property() == existing_inobject_property);
     DCHECK(RepresentationField::decode(value_) == representation.kind());
     DCHECK(!this->existing_inobject_property() || IsInobject());
   }
 
   class PortionField : public BitField<Portion, 0, 3> {};
   class RepresentationField : public BitField<Representation::Kind, 3, 4> {};
   class ImmutableField : public BitField<bool, 7, 1> {};
   class ExistingInobjectPropertyField : public BitField<bool, 8, 1> {};
-  class OffsetField : public BitField<int, 9, 23> {};
+  class ReadBarrierField : public BitField<bool, 9, 1> {};
+  class OffsetField : public BitField<int, 10, 22> {};
 
   uint32_t value_;  // encodes portion, representation, immutable, and offset
   Handle<String> name_;
 
   friend class HLoadNamedField;
   friend class HStoreNamedField;
   friend class SideEffectsTracker;
   friend std::ostream& operator<<(std::ostream& os,
                                   const HObjectAccess& access);
 
@@ skipping 1561 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_