Replace ad-hoc weakness in transition array with WeakCell.

src/transitions.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_TRANSITIONS_H_
 #define V8_TRANSITIONS_H_
 
 #include "src/checks.h"
 #include "src/elements-kind.h"
 #include "src/heap/heap.h"
@@ skipping 53 matching lines @@
            WeakCell::cast(raw_transition)->cleared() ||
            WeakCell::cast(raw_transition)->value()->IsMap());
     return raw_transition->IsWeakCell() &&
            !WeakCell::cast(raw_transition)->cleared();
   }
   static inline Map* GetSimpleTransition(Object* raw_transition) {
     DCHECK(IsSimpleTransition(raw_transition));
     DCHECK(raw_transition->IsWeakCell());
     return Map::cast(WeakCell::cast(raw_transition)->value());
   }
+  static inline WeakCell* GetSimpleTransitionCell(Object* raw_transition) {
+    DCHECK(IsSimpleTransition(raw_transition));
+    DCHECK(raw_transition->IsWeakCell());
+    return WeakCell::cast(raw_transition);
+  }
   static inline bool IsFullTransitionArray(Object* raw_transitions) {
     return raw_transitions->IsTransitionArray();
   }
 
   // The size of transition arrays are limited so they do not end up in large
   // object space. Otherwise ClearNonLiveReferences would leak memory while
   // applying in-place right trimming.
   static bool CanHaveMoreTransitions(Handle<Map> map);
 
   // ===== PROTOTYPE TRANSITIONS =====
@@ skipping 44 matching lines @@
     TraverseTransitionTreeInternal(map, callback, data);
   }
 
   // ===== LOW-LEVEL ACCESSORS =====
 
   // Accessors for fetching instance transition at transition number.
   static inline Name* GetKey(Object* raw_transitions, int transition_number);
   inline Name* GetKey(int transition_number);
   inline void SetKey(int transition_number, Name* value);
   inline Object** GetKeySlot(int transition_number);
+  inline Object** GetTargetSlot(int transition_number);
   int GetSortedKeyIndex(int transition_number) { return transition_number; }
 
   Name* GetSortedKey(int transition_number) {
     return GetKey(transition_number);
   }
 
   static inline Map* GetTarget(Object* raw_transitions, int transition_number);
   inline Map* GetTarget(int transition_number);
-  inline void SetTarget(int transition_number, Map* target);
+
+  inline WeakCell* GetTargetCell(int transition_number);
+  inline void SetTargetCell(int transition_number, WeakCell* target);
 
   static inline PropertyDetails GetTargetDetails(Name* name, Map* target);
 
   // Returns the number of transitions in the array.
   static int NumberOfTransitions(Object* raw_transitions);
   // Required for templatized Search interface.
   inline int number_of_entries() { return number_of_transitions(); }
 
   inline void SetNumberOfTransitions(int number_of_transitions);
 
@@ skipping 119 matching lines @@
   static inline int CompareNames(Name* key1, uint32_t hash1, Name* key2,
                                  uint32_t hash2);
 
   // Compares two details, returns -1 if details1 is "less" than details2,
   // 0 if details1 equal to details2 and 1 otherwise.
   static inline int CompareDetails(PropertyKind kind1,
                                    PropertyAttributes attributes1,
                                    PropertyKind kind2,
                                    PropertyAttributes attributes2);
 
-  inline void NoIncrementalWriteBarrierSet(int transition_number,
-                                           Name* key,
-                                           Map* target);
+  inline void Set(int transition_number, Name* key, WeakCell* target_cell);
 
   // Copy a single transition from the origin array.
-  inline void NoIncrementalWriteBarrierCopyFrom(TransitionArray* origin,
-                                                int origin_transition,
-                                                int target_transition);
+  inline void CopyFrom(TransitionArray* origin, int origin_transition,
+                       int target_transition);
 
 #ifdef DEBUG
   static void CheckNewTransitionsAreConsistent(Handle<Map> map,
                                                TransitionArray* old_transitions,
                                                Object* transitions);
 #endif
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(TransitionArray);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TRANSITIONS_H_