Allow property indexes to refer to slots inside the object header.

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 114 matching lines @@
 class CallbacksDescriptor:  public Descriptor {
  public:
   CallbacksDescriptor(String* key,
                       Object* foreign,
                       PropertyAttributes attributes,
                       int index = 0)
       : Descriptor(key, foreign, attributes, CALLBACKS, index) {}
 };
 
 
+// Hold a property index value distinguishing if it is a field index or an

[Jakob Kummerow, 2012/11/13 10:44:43]

nit: s/Hold/Holds/

+// index inside the object header.
+class PropertyIndex {
+ public:
+  static PropertyIndex NewFieldIndex(int index) {
+    return PropertyIndex(index, false);
+  }
+  static PropertyIndex NewHeaderIndex(int index) {
+    return PropertyIndex(index, true);
+  }
+
+  bool IsFieldIndex() { return (index_ & kHeaderIndexBit) == 0; }

[Jakob Kummerow, 2012/11/13 10:44:43]

nit: I think for this and the next three methods, unix_hacker_style names would
be appropriate, as they're essentially simple getters.

+  bool IsHeaderIndex() { return (index_ & kHeaderIndexBit) != 0; }
+
+  int FieldIndex() {
+    ASSERT(IsFieldIndex());
+    return value();
+  }
+  int HeaderIndex() {
+    ASSERT(IsHeaderIndex());
+    return value();
+  }
+
+  int RawIndex() { return index_; }

[Jakob Kummerow, 2012/11/13 10:44:43]

I don't see this ever getting called.

+
+ private:
+  static const int kHeaderIndexBit = 1 << 31;
+  static const int kIndexMask = ~kHeaderIndexBit;
+
+  int value() { return index_ & kIndexMask; }
+
+  int index_;
+  PropertyIndex(int index, bool isHeaderBased) :

[Jakob Kummerow, 2012/11/13 10:44:43]

nit1: ':' should be on the second line (see e.g. the LookupResult constructor
right below).

nit2: is_header_based. (Usually, we also prefer enums over bools, but since this
method is local to the class, using a bool is OK.)

nit3: within the "private:" section, please adhere to the ordering statics ->
methods -> fields.

+      index_(index | (isHeaderBased ? kHeaderIndexBit : 0)) {
+    ASSERT(index <= kIndexMask);
+  }
+};
+

[Jakob Kummerow, 2012/11/13 10:44:43]

nit: two lines of whitespace between top-level definitions

 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);
@@ skipping 126 matching lines @@
   bool IsProperty() {
     return IsFound() && !IsTransition();
   }
 
   bool IsCacheable() { return cacheable_; }
   void DisallowCaching() { cacheable_ = false; }
 
   Object* GetLazyValue() {
     switch (type()) {
       case FIELD:
-        return holder()->FastPropertyAt(GetFieldIndex());
+        return holder()->FastPropertyAt(GetFieldIndex().FieldIndex());
       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();
@@ skipping 35 matching lines @@
   int GetTransitionIndex() {
     ASSERT(IsTransition());
     return number_;
   }
 
   int GetDescriptorIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     return number_;
   }
 
-  int GetFieldIndex() {
+  PropertyIndex GetFieldIndex() {
     ASSERT(lookup_type_ == DESCRIPTOR_TYPE);
     ASSERT(IsField());
-    return Descriptor::IndexFromValue(GetValue());
+    return PropertyIndex::NewFieldIndex(
+        Descriptor::IndexFromValue(GetValue()));
   }
 
   int GetLocalFieldIndexFromMap(Map* map) {
     ASSERT(IsField());
     return Descriptor::IndexFromValue(GetValueFromMap(map)) -
         map->inobject_properties();
   }
 
   int GetDictionaryEntry() {
     ASSERT(lookup_type_ == DICTIONARY_TYPE);
@@ skipping 57 matching lines @@
   JSReceiver* holder_;
   int number_;
   bool cacheable_;
   PropertyDetails details_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_H_