Reset trunk to 3.24.35.4

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 166 matching lines @@
 };
 
 
 class LookupResult BASE_EMBEDDED {
  public:
   explicit LookupResult(Isolate* isolate)
       : isolate_(isolate),
         next_(isolate->top_lookup_result()),
         lookup_type_(NOT_FOUND),
         holder_(NULL),
-        transition_(NULL),
         cacheable_(true),
         details_(NONE, NONEXISTENT, Representation::None()) {
-    isolate->set_top_lookup_result(this);
+    isolate->SetTopLookupResult(this);
   }
 
   ~LookupResult() {
     ASSERT(isolate()->top_lookup_result() == this);
-    isolate()->set_top_lookup_result(next_);
+    isolate()->SetTopLookupResult(next_);
   }
 
   Isolate* isolate() const { return isolate_; }
 
   void DescriptorResult(JSObject* holder, PropertyDetails details, int number) {
     lookup_type_ = DESCRIPTOR_TYPE;
     holder_ = holder;
-    transition_ = NULL;
     details_ = details;
     number_ = number;
   }
 
   bool CanHoldValue(Handle<Object> value) {
     if (IsNormal()) return true;
     ASSERT(!IsTransition());
     return value->FitsRepresentation(details_.representation());
   }
 
-  void TransitionResult(JSObject* holder, Map* target) {
+  void TransitionResult(JSObject* holder, int number) {
     lookup_type_ = TRANSITION_TYPE;
     details_ = PropertyDetails(NONE, TRANSITION, Representation::None());
     holder_ = holder;
-    transition_ = target;
-    number_ = 0xAAAA;
+    number_ = number;
   }
 
   void DictionaryResult(JSObject* holder, int entry) {
     lookup_type_ = DICTIONARY_TYPE;
     holder_ = holder;
-    transition_ = NULL;
     details_ = holder->property_dictionary()->DetailsAt(entry);
     number_ = entry;
   }
 
   void HandlerResult(JSProxy* proxy) {
     lookup_type_ = HANDLER_TYPE;
     holder_ = proxy;
-    transition_ = NULL;
     details_ = PropertyDetails(NONE, HANDLER, Representation::Tagged());
     cacheable_ = false;
   }
 
   void InterceptorResult(JSObject* holder) {
     lookup_type_ = INTERCEPTOR_TYPE;
     holder_ = holder;
-    transition_ = NULL;
     details_ = PropertyDetails(NONE, INTERCEPTOR, Representation::Tagged());
   }
 
   void NotFound() {
     lookup_type_ = NOT_FOUND;
     details_ = PropertyDetails(NONE, NONEXISTENT, Representation::None());
     holder_ = NULL;
-    transition_ = NULL;
   }
 
-  JSObject* holder() const {
+  JSObject* holder() {
     ASSERT(IsFound());
     return JSObject::cast(holder_);
   }
 
-  JSProxy* proxy() const {
-    ASSERT(IsHandler());
+  JSProxy* proxy() {
+    ASSERT(IsFound());
     return JSProxy::cast(holder_);
   }
 
-  PropertyType type() const {
+  PropertyType type() {
     ASSERT(IsFound());
     return details_.type();
   }
 
-  Representation representation() const {
+  Representation representation() {
     ASSERT(IsFound());
     ASSERT(!IsTransition());
     ASSERT(details_.type() != NONEXISTENT);
     return details_.representation();
   }
 
-  PropertyAttributes GetAttributes() const {
+  PropertyAttributes GetAttributes() {
     ASSERT(!IsTransition());
     ASSERT(IsFound());
     ASSERT(details_.type() != NONEXISTENT);
     return details_.attributes();
   }
 
-  PropertyDetails GetPropertyDetails() const {
+  PropertyDetails GetPropertyDetails() {
     ASSERT(!IsTransition());
     return details_;
   }
 
-  bool IsFastPropertyType() const {
+  bool IsFastPropertyType() {
     ASSERT(IsFound());
     return IsTransition() || type() != NORMAL;
   }
 
   // Property callbacks does not include transitions to callbacks.
-  bool IsPropertyCallbacks() const {
+  bool IsPropertyCallbacks() {
     ASSERT(!(details_.type() == CALLBACKS && !IsFound()));
     return details_.type() == CALLBACKS;
   }
 
-  bool IsReadOnly() const {
+  bool IsReadOnly() {
     ASSERT(IsFound());
     ASSERT(!IsTransition());
     ASSERT(details_.type() != NONEXISTENT);
     return details_.IsReadOnly();
   }
 
-  bool IsField() const {
+  bool IsField() {
     ASSERT(!(details_.type() == FIELD && !IsFound()));
     return details_.type() == FIELD;
   }
 
-  bool IsNormal() const {
+  bool IsNormal() {
     ASSERT(!(details_.type() == NORMAL && !IsFound()));
     return details_.type() == NORMAL;
   }
 
-  bool IsConstant() const {
+  bool IsConstant() {
     ASSERT(!(details_.type() == CONSTANT && !IsFound()));
     return details_.type() == CONSTANT;
   }
 
-  bool IsConstantFunction() const {
+  bool IsConstantFunction() {
     return IsConstant() && GetValue()->IsJSFunction();
   }
 
-  bool IsDontDelete() const { return details_.IsDontDelete(); }
-  bool IsDontEnum() const { return details_.IsDontEnum(); }
-  bool IsFound() const { return lookup_type_ != NOT_FOUND; }
-  bool IsTransition() const { return lookup_type_ == TRANSITION_TYPE; }
-  bool IsHandler() const { return lookup_type_ == HANDLER_TYPE; }
-  bool IsInterceptor() const { return lookup_type_ == INTERCEPTOR_TYPE; }
+  bool IsDontDelete() { return details_.IsDontDelete(); }
+  bool IsDontEnum() { return details_.IsDontEnum(); }
+  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() const {
+  bool IsProperty() {
     return IsFound() && !IsTransition();
   }
 
-  bool IsDataProperty() const {
+  bool IsDataProperty() {
     switch (type()) {
       case FIELD:
       case NORMAL:
       case CONSTANT:
         return true;
       case CALLBACKS: {
         Object* callback = GetCallbackObject();
         return callback->IsAccessorInfo() || callback->IsForeign();
       }
       case HANDLER:
       case INTERCEPTOR:
       case TRANSITION:
       case NONEXISTENT:
         return false;
     }
     UNREACHABLE();
     return false;
   }
 
-  bool IsCacheable() const { return cacheable_; }
+  bool IsCacheable() { return cacheable_; }
   void DisallowCaching() { cacheable_ = false; }
 
-  Object* GetLazyValue() const {
+  Object* GetLazyValue() {
     switch (type()) {
       case FIELD:
         return holder()->RawFastPropertyAt(GetFieldIndex().field_index());
       case NORMAL: {
         Object* value;
         value = holder()->property_dictionary()->ValueAt(GetDictionaryEntry());
         if (holder()->IsGlobalObject()) {
           value = PropertyCell::cast(value)->value();
         }
         return value;
       }
       case CONSTANT:
         return GetConstant();
       case CALLBACKS:
       case HANDLER:
       case INTERCEPTOR:
       case TRANSITION:
       case NONEXISTENT:
         return isolate()->heap()->the_hole_value();
     }
     UNREACHABLE();
     return NULL;
   }
 
-  Map* GetTransitionTarget() const {
-    return transition_;
+  Map* GetTransitionTarget(Map* map) {
+    ASSERT(IsTransition());
+    TransitionArray* transitions = map->transitions();
+    return transitions->GetTarget(number_);
   }
 
-  PropertyDetails GetTransitionDetails() const {
-    ASSERT(IsTransition());
-    return transition_->GetLastDescriptorDetails();
+  Map* GetTransitionTarget() {
+    return GetTransitionTarget(holder()->map());
   }
 
-  bool IsTransitionToField() const {
-    return IsTransition() && GetTransitionDetails().type() == FIELD;
+  PropertyDetails GetTransitionDetails(Map* map) {
+    ASSERT(IsTransition());
+    TransitionArray* transitions = map->transitions();
+    return transitions->GetTargetDetails(number_);
   }
 
-  bool IsTransitionToConstant() const {
-    return IsTransition() && GetTransitionDetails().type() == CONSTANT;
+  PropertyDetails GetTransitionDetails() {
+    return GetTransitionDetails(holder()->map());
   }
 
-  int GetDescriptorIndex() const {
+  bool IsTransitionToField(Map* map) {
+    return IsTransition() && GetTransitionDetails(map).type() == FIELD;
+  }
+
+  bool IsTransitionToConstant(Map* map) {
+    return IsTransition() && GetTransitionDetails(map).type() == CONSTANT;
+  }
+
+  Map* GetTransitionMap() {
+    ASSERT(IsTransition());
+    return Map::cast(GetValue());
+  }
+
+  Map* GetTransitionMapFromMap(Map* map) {
+    ASSERT(IsTransition());
+    return map->transitions()->GetTarget(number_);
+  }
+
+  int GetTransitionIndex() {
+    ASSERT(IsTransition());
+    return number_;
+  }
+
+  int GetDescriptorIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     return number_;
   }
 
-  PropertyIndex GetFieldIndex() const {
+  PropertyIndex GetFieldIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     return PropertyIndex::NewFieldIndex(GetFieldIndexFromMap(holder()->map()));
   }
 
-  int GetLocalFieldIndexFromMap(Map* map) const {
+  int GetLocalFieldIndexFromMap(Map* map) {
     return GetFieldIndexFromMap(map) - map->inobject_properties();
   }
 
-  int GetDictionaryEntry() const {
+  int GetDictionaryEntry() {
     ASSERT(lookup_type_ == DICTIONARY_TYPE);
     return number_;
   }
 
-  JSFunction* GetConstantFunction() const {
+  JSFunction* GetConstantFunction() {
     ASSERT(type() == CONSTANT);
     return JSFunction::cast(GetValue());
   }
 
-  Object* GetConstantFromMap(Map* map) const {
+  Object* GetConstantFromMap(Map* map) {
     ASSERT(type() == CONSTANT);
     return GetValueFromMap(map);
   }
 
-  JSFunction* GetConstantFunctionFromMap(Map* map) const {
+  JSFunction* GetConstantFunctionFromMap(Map* map) {
     return JSFunction::cast(GetConstantFromMap(map));
   }
 
-  Object* GetConstant() const {
+  Object* GetConstant() {
     ASSERT(type() == CONSTANT);
     return GetValue();
   }
 
-  Object* GetCallbackObject() const {
+  Object* GetCallbackObject() {
     ASSERT(type() == CALLBACKS && !IsTransition());
     return GetValue();
   }
 
 #ifdef OBJECT_PRINT
   void Print(FILE* out);
 #endif
 
-  Object* GetValue() const {
+  Object* GetValue() {
     if (lookup_type_ == DESCRIPTOR_TYPE) {
       return GetValueFromMap(holder()->map());
     }
     // In the dictionary case, the data is held in the value field.
     ASSERT(lookup_type_ == DICTIONARY_TYPE);
     return holder()->GetNormalizedProperty(this);
   }
 
   Object* GetValueFromMap(Map* map) const {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
@@ skipping 17 matching lines @@
   enum {
     NOT_FOUND,
     DESCRIPTOR_TYPE,
     TRANSITION_TYPE,
     DICTIONARY_TYPE,
     HANDLER_TYPE,
     INTERCEPTOR_TYPE
   } lookup_type_;
 
   JSReceiver* holder_;
-  Map* transition_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_