Separating transitions from descriptors.

src/property.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_PROPERTY_H_
 #define V8_PROPERTY_H_
 
 #include "allocation.h"
+#include "transitions.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Abstraction for elements in instance-descriptor arrays.
 //
 // Each descriptor has a key, property attributes, property type,
 // property index (in the actual instance-descriptor array) and
 // optionally a piece of data.
@@ skipping 19 matching lines @@
 
 #ifdef OBJECT_PRINT
   void Print(FILE* out);
 #endif
 
   void SetEnumerationIndex(int index) {
     ASSERT(PropertyDetails::IsValidIndex(index));
     details_ = PropertyDetails(details_.attributes(), details_.type(), index);
   }
 
-  bool ContainsTransition();
-
  private:
   String* key_;
   Object* value_;
   PropertyDetails details_;
 
  protected:
   Descriptor() : details_(Smi::FromInt(0)) {}
 
   void Init(String* key, Object* value, PropertyDetails details) {
     key_ = key;
@@ skipping 11 matching lines @@
              PropertyAttributes attributes,
              PropertyType type,
              int index = 0)
       : key_(key),
         value_(value),
         details_(attributes, type, index) { }
 
   friend class DescriptorArray;
 };
 
-// A pointer from a map to the new map that is created by adding
-// a named property.  These are key to the speed and functioning of V8.
-// The two maps should always have the same prototype, since
-// MapSpace::CreateBackPointers depends on this.
-class MapTransitionDescriptor: public Descriptor {
- public:
-  MapTransitionDescriptor(String* key, Map* map, PropertyAttributes attributes)
-      : Descriptor(key, map, attributes, MAP_TRANSITION) { }
-};
-
-// Marks a field name in a map so that adding the field is guaranteed
-// to create a FIELD descriptor in the new map.  Used after adding
-// a constant function the first time, creating a CONSTANT_FUNCTION
-// descriptor in the new map.  This avoids creating multiple maps with
-// the same CONSTANT_FUNCTION field.
-class ConstTransitionDescriptor: public Descriptor {
- public:
-  explicit ConstTransitionDescriptor(String* key, Map* map)
-      : Descriptor(key, map, NONE, CONSTANT_TRANSITION) { }
-};
-
 
 class FieldDescriptor: public Descriptor {
  public:
   FieldDescriptor(String* key,
                   int field_index,
                   PropertyAttributes attributes,
                   int index = 0)
       : Descriptor(key, Smi::FromInt(field_index), attributes, FIELD, index) {}
 };
 
@@ skipping 11 matching lines @@
 class CallbacksDescriptor:  public Descriptor {
  public:
   CallbacksDescriptor(String* key,
                       Object* foreign,
                       PropertyAttributes attributes,
                       int index = 0)
       : Descriptor(key, foreign, attributes, CALLBACKS, index) {}
 };
 
 
-template <class T>
-bool IsPropertyDescriptor(T* desc) {
-  switch (desc->type()) {
-    case NORMAL:
-    case FIELD:
-    case CONSTANT_FUNCTION:
-    case HANDLER:
-    case INTERCEPTOR:
-      return true;
-    case CALLBACKS: {
-      Object* callback_object = desc->GetCallbackObject();
-      // Non-JavaScript (i.e. native) accessors are always a property, otherwise
-      // either the getter or the setter must be an accessor. Put another way:
-      // If we only see map transitions and holes in a pair, this is not a
-      // property.
-      return (!callback_object->IsAccessorPair() ||
-              AccessorPair::cast(callback_object)->ContainsAccessor());
-    }
-    case MAP_TRANSITION:
-    case CONSTANT_TRANSITION:
-      return false;
-    case NONEXISTENT:
-      UNREACHABLE();
-      break;
-  }
-  UNREACHABLE();  // keep the compiler happy
-  return false;
-}
-
-
 class LookupResult BASE_EMBEDDED {
  public:
   explicit LookupResult(Isolate* isolate)
       : isolate_(isolate),
         next_(isolate->top_lookup_result()),
         lookup_type_(NOT_FOUND),
         holder_(NULL),
         cacheable_(true),
         details_(NONE, NONEXISTENT) {
     isolate->SetTopLookupResult(this);
   }
 
   ~LookupResult() {
     ASSERT(isolate_->top_lookup_result() == this);
     isolate_->SetTopLookupResult(next_);
   }
 
   void DescriptorResult(JSObject* holder, PropertyDetails details, int number) {
     lookup_type_ = DESCRIPTOR_TYPE;
     holder_ = holder;
     details_ = details;
     number_ = number;
   }
 
+  void TransitionResult(JSObject* holder, int number) {
+    lookup_type_ = TRANSITION_TYPE;
+    details_ = PropertyDetails(NONE, TRANSITION);
+    holder_ = holder;
+    number_ = number;
+  }
+
   void ConstantResult(JSObject* holder) {
     lookup_type_ = CONSTANT_TYPE;
     holder_ = holder;
     details_ =
         PropertyDetails(static_cast<PropertyAttributes>(DONT_ENUM |
                                                         DONT_DELETE),
                         CALLBACKS);
     number_ = -1;
   }
 
@@ skipping 32 matching lines @@
     ASSERT(IsFound());
     return JSProxy::cast(holder_);
   }
 
   PropertyType type() {
     ASSERT(IsFound());
     return details_.type();
   }
 
   PropertyAttributes GetAttributes() {
+    ASSERT(!IsTransition());
     ASSERT(IsFound());
+    ASSERT(details_.type() != NONEXISTENT);
     return details_.attributes();
   }
 
   PropertyDetails GetPropertyDetails() {
+    ASSERT(!IsTransition());
     return details_;
   }
 
   bool IsFastPropertyType() {
     ASSERT(IsFound());
-    return type() != NORMAL;
+    return IsTransition() || type() != NORMAL;
+  }
+
+  // Property callbacks does not include transitions to callbacks.
+  bool IsPropertyCallbacks() {
+    ASSERT(!(details_.type() == CALLBACKS && !IsFound()));
+    return details_.type() == CALLBACKS;
+  }
+
+  // Is callbacks contains both property callbacks and transitions to callbacks.
+  bool IsCallbacks() {
+    return IsPropertyCallbacks() ||
+           (IsTransition() && GetTransitionValue()->IsAccessorPair());
   }
 
   bool IsReadOnly() {
     ASSERT(IsFound());
+    ASSERT(!IsTransition());
+    ASSERT(details_.type() != NONEXISTENT);
     return details_.IsReadOnly();
   }
 
-  bool IsCallbacks() {
-    ASSERT(!(details_.type() == CALLBACKS && !IsFound()));
-    return details_.type() == CALLBACKS;
-  }
-
   bool IsField() {
     ASSERT(!(details_.type() == FIELD && !IsFound()));
     return details_.type() == FIELD;
   }
 
   bool IsNormal() {
     ASSERT(!(details_.type() == NORMAL && !IsFound()));
     return details_.type() == NORMAL;
   }
 
   bool IsConstantFunction() {
     ASSERT(!(details_.type() == CONSTANT_FUNCTION && !IsFound()));
     return details_.type() == CONSTANT_FUNCTION;
   }
 
-  bool IsMapTransition() {
-    ASSERT(!(details_.type() == MAP_TRANSITION && !IsFound()));
-    return details_.type() == MAP_TRANSITION;
-  }
-
   bool IsDontDelete() { return details_.IsDontDelete(); }
   bool IsDontEnum() { return details_.IsDontEnum(); }
   bool IsDeleted() { return details_.IsDeleted(); }
   bool IsFound() { return lookup_type_ != NOT_FOUND; }
+  bool IsTransition() { return lookup_type_ == TRANSITION_TYPE; }
   bool IsHandler() { return lookup_type_ == HANDLER_TYPE; }
   bool IsInterceptor() { return lookup_type_ == INTERCEPTOR_TYPE; }
 
   // Is the result is a property excluding transitions and the null descriptor?
   bool IsProperty() {
-    return IsFound() && IsPropertyDescriptor(this);
+    return IsFound() && !IsTransition();
   }
 
   bool IsCacheable() { return cacheable_; }
   void DisallowCaching() { cacheable_ = false; }
 
   Object* GetLazyValue() {
     switch (type()) {
       case FIELD:
         return holder()->FastPropertyAt(GetFieldIndex());
       case NORMAL: {
         Object* value;
         value = holder()->property_dictionary()->ValueAt(GetDictionaryEntry());
         if (holder()->IsGlobalObject()) {
           value = JSGlobalPropertyCell::cast(value)->value();
         }
         return value;
       }
       case CONSTANT_FUNCTION:
         return GetConstantFunction();
       default:
         return Smi::FromInt(0);
     }
   }
 
+  Object* GetTransitionValue() {
+    ASSERT(IsTransition());
+    TransitionArray* transitions = holder()->map()->transitions();
+    Object* value = transitions->GetValue(number_);
+    return value;
+  }
+
+  PropertyDetails GetTransitionDetails(Map* map) {
+    ASSERT(IsTransition());
+    TransitionArray* transitions = map->transitions();
+    return transitions->GetTargetDetails(number_);
+  }
+
+  PropertyDetails GetTransitionDetails() {
+    return GetTransitionDetails(holder()->map());
+  }
+
+  bool IsTransitionToField(Map* map) {
+    return IsTransition() && GetTransitionDetails(map).type() == FIELD;
+  }
+
   Map* GetTransitionMap() {
-    ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
-    ASSERT(type() == MAP_TRANSITION ||
-           type() == CONSTANT_TRANSITION);
+    ASSERT(IsTransition());
     return Map::cast(GetValue());
   }
 
   Map* GetTransitionMapFromMap(Map* map) {
-    ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
-    ASSERT(type() == MAP_TRANSITION);
-    return Map::cast(map->instance_descriptors()->GetValue(number_));
+    ASSERT(IsTransition());
+    return Map::cast(map->transitions()->GetValue(number_));
   }
 
   int GetFieldIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(IsField());
     return Descriptor::IndexFromValue(GetValue());
   }
 
   int GetLocalFieldIndexFromMap(Map* map) {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
@@ skipping 13 matching lines @@
     return JSFunction::cast(GetValue());
   }
 
   JSFunction* GetConstantFunctionFromMap(Map* map) {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(type() == CONSTANT_FUNCTION);
     return JSFunction::cast(map->instance_descriptors()->GetValue(number_));
   }
 
   Object* GetCallbackObject() {
-    if (lookup_type_ == CONSTANT_TYPE) {
-      // For now we only have the __proto__ as constant type.
-      return HEAP->prototype_accessors();
+    switch (lookup_type_) {
+      case CONSTANT_TYPE:
+        return HEAP->prototype_accessors();
+      case TRANSITION_TYPE:
+        return GetTransitionValue();
+      default:
+        return GetValue();
     }
-    return GetValue();
   }
 
 #ifdef OBJECT_PRINT
   void Print(FILE* out);
 #endif
 
   Object* GetValue() {
     if (lookup_type_ == DESCRIPTOR_TYPE) {
       DescriptorArray* descriptors = holder()->map()->instance_descriptors();
       return descriptors->GetValue(number_);
     }
     // In the dictionary case, the data is held in the value field.
     ASSERT(lookup_type_ == DICTIONARY_TYPE);
     return holder()->GetNormalizedProperty(this);
   }
 
   void Iterate(ObjectVisitor* visitor);
 
  private:
   Isolate* isolate_;
   LookupResult* next_;
 
   // Where did we find the result;
   enum {
     NOT_FOUND,
     DESCRIPTOR_TYPE,
+    TRANSITION_TYPE,
     DICTIONARY_TYPE,
     HANDLER_TYPE,
     INTERCEPTOR_TYPE,
     CONSTANT_TYPE
   } lookup_type_;
 
   JSReceiver* holder_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_