Add map-based read barrier to WeakCell

src/code-stubs-hydrogen.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
 #include "src/code-stubs.h"
 #include "src/field-index.h"
 #include "src/hydrogen.h"
@@ skipping 518 matching lines @@
 template <>
 HValue* CodeStubGraphBuilder<CreateWeakCellStub>::BuildCodeStub() {
   // This stub is performance sensitive, the generated code must be tuned
   // so that it doesn't build an eager frame.
   info()->MarkMustNotHaveEagerFrame();
 
   HValue* size = Add<HConstant>(WeakCell::kSize);
   HInstruction* object =
       Add<HAllocate>(size, HType::JSObject(), TENURED, JS_OBJECT_TYPE);
 
-  Handle<Map> weak_cell_map = isolate()->factory()->weak_cell_map();
+  Handle<Map> weak_cell_map = isolate()->factory()->used_weak_cell_map();
   AddStoreMapConstant(object, weak_cell_map);
 
   HInstruction* value = GetParameter(CreateWeakCellDescriptor::kValueIndex);
   Add<HStoreNamedField>(object, HObjectAccess::ForWeakCellValue(), value);
   Add<HStoreNamedField>(object, HObjectAccess::ForWeakCellNext(),
                         graph()->GetConstantUndefined());
 
   HInstruction* feedback_vector =
       GetParameter(CreateWeakCellDescriptor::kVectorIndex);
   HInstruction* slot = GetParameter(CreateWeakCellDescriptor::kSlotIndex);
@@ skipping 783 matching lines @@
   if (stub->check_global()) {
     // Check that the map of the global has not changed: use a placeholder map
     // that will be replaced later with the global object's map.
     HParameter* proxy = GetParameter(StoreDescriptor::kReceiverIndex);
     HValue* proxy_map =
         Add<HLoadNamedField>(proxy, nullptr, HObjectAccess::ForMap());
     HValue* global =
         Add<HLoadNamedField>(proxy_map, nullptr, HObjectAccess::ForPrototype());
     Handle<Map> placeholder_map = isolate()->factory()->meta_map();
     HValue* cell = Add<HConstant>(Map::WeakCellForMap(placeholder_map));
-    HValue* expected_map =
-        Add<HLoadNamedField>(cell, nullptr, HObjectAccess::ForWeakCellValue());
+    HValue* expected_map = Add<HLoadNamedField>(
+        cell, nullptr, HObjectAccess::ForWeakCellValueComparison());
     HValue* map =
         Add<HLoadNamedField>(global, nullptr, HObjectAccess::ForMap());
     IfBuilder map_check(this);
     map_check.IfNot<HCompareObjectEqAndBranch>(expected_map, map);
     map_check.ThenDeopt(Deoptimizer::kUnknownMap);
     map_check.End();
   }
 
   HValue* weak_cell = Add<HConstant>(isolate()->factory()->NewWeakCell(
       StoreGlobalStub::property_cell_placeholder(isolate())));
@@ skipping 726 matching lines @@
   Push(heap_number_map);
   if_receiver_heap_object.End();
   HValue* receiver_map = Pop();
 
   HValue* start =
       keyed_load ? graph()->GetConstant1() : graph()->GetConstant0();
   HValue* weak_cell =
       Add<HLoadKeyed>(array, start, nullptr, FAST_ELEMENTS, ALLOW_RETURN_HOLE);
   // Load the weak cell value. It may be Smi(0), or a map. Compare nonetheless
   // against the receiver_map.
-  HValue* array_map = Add<HLoadNamedField>(weak_cell, nullptr,
-                                           HObjectAccess::ForWeakCellValue());
+  HValue* array_map = Add<HLoadNamedField>(
+      weak_cell, nullptr, HObjectAccess::ForWeakCellValueComparison());
 
   IfBuilder if_correct_map(this);
   if_correct_map.If<HCompareObjectEqAndBranch>(receiver_map, array_map);
   if_correct_map.Then();
   { TailCallHandler(receiver, name, array, start, slot, vector); }
   if_correct_map.Else();
   {
     // If our array has more elements, the ic is polymorphic. Look for the
     // receiver map in the rest of the array.
     HValue* length = AddLoadFixedArrayLength(array, nullptr);
     LoopBuilder builder(this, context(), LoopBuilder::kPostIncrement,
                         constant_two);
     start = keyed_load ? constant_three : constant_two;
     HValue* key = builder.BeginBody(start, length, Token::LT);
     {
       HValue* weak_cell = Add<HLoadKeyed>(array, key, nullptr, FAST_ELEMENTS,
                                           ALLOW_RETURN_HOLE);
       HValue* array_map = Add<HLoadNamedField>(
-          weak_cell, nullptr, HObjectAccess::ForWeakCellValue());
+          weak_cell, nullptr, HObjectAccess::ForWeakCellValueComparison());
       IfBuilder if_correct_poly_map(this);
       if_correct_poly_map.If<HCompareObjectEqAndBranch>(receiver_map,
                                                         array_map);
       if_correct_poly_map.Then();
       { TailCallHandler(receiver, name, array, key, slot, vector); }
     }
     builder.EndBody();
   }
   if_correct_map.End();
 }
@@ skipping 126 matching lines @@
   // megamorphic case is handled as part of the default stub.
   DCHECK(!FLAG_vector_ics);
 
   // Probe the stub cache.
   Add<HTailCallThroughMegamorphicCache>(receiver, name);
 
   // We never continue.
   return graph()->GetConstant0();
 }
 } }  // namespace v8::internal