Hydrogenized KeyedLoadGeneric stub: Fix FieldIndex::GetLoadByFieldIndex()

src/field-index-inl.h

 // Copyright 2014 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_FIELD_INDEX_INL_H_
 #define V8_FIELD_INDEX_INL_H_
 
 #include "src/field-index.h"
 
 namespace v8 {
@@ skipping 27 matching lines @@
   } else {
     first_inobject_offset = FixedArray::kHeaderSize;
     property_index -= inobject_properties;
   }
   return FieldIndex(is_inobject,
                     property_index + first_inobject_offset / kPointerSize,
                     is_double, inobject_properties, first_inobject_offset);
 }
 
 
+// Takes an index as computed by GetLoadFieldByIndex and reconstructs a
+// FieldIndex object from it.
 inline FieldIndex FieldIndex::ForLoadByFieldIndex(Map* map, int orig_index) {
   int field_index = orig_index;
   int is_inobject = true;
   bool is_double = field_index & 1;
   int first_inobject_offset = 0;
   field_index >>= 1;
   if (field_index < 0) {
     field_index = -(field_index + 1);
     is_inobject = false;
     first_inobject_offset = FixedArray::kHeaderSize;
     field_index += FixedArray::kHeaderSize / kPointerSize;
   } else {
     first_inobject_offset = map->GetInObjectPropertyOffset(0);
     field_index += JSObject::kHeaderSize / kPointerSize;
   }
-  return FieldIndex(is_inobject, field_index, is_double,
+  FieldIndex result(is_inobject, field_index, is_double,
                     map->inobject_properties(), first_inobject_offset);
+  ASSERT(result.GetLoadByFieldIndex() == orig_index);
+  return result;
 }
 
 
+// Returns the index format accepted by the HLoadFieldByIndex instruction.
+// (In-object: zero-based from (object start + JSObject::kHeaderSize),
+// out-of-object: zero-based from FixedArray::kHeaderSize.)
+inline int FieldIndex::GetLoadByFieldIndex() const {
+  // For efficiency, the LoadByFieldIndex instruction takes an index that is
+  // optimized for quick access. If the property is inline, the index is
+  // positive. If it's out-of-line, the encoded index is -raw_index - 1 to
+  // disambiguate the zero out-of-line index from the zero inobject case.
+  // The index itself is shifted up by one bit, the lower-most bit
+  // signifying if the field is a mutable double box (1) or not (0).
+  int result = index();
+  if (is_inobject()) {
+    result -= JSObject::kHeaderSize / kPointerSize;
+  } else {
+    result -= FixedArray::kHeaderSize / kPointerSize;
+    result = -result - 1;
+  }
+  result <<= 1;
+  return is_double() ? (result | 1) : result;
+}
+
+
 inline FieldIndex FieldIndex::ForDescriptor(Map* map, int descriptor_index) {
   PropertyDetails details =
       map->instance_descriptors()->GetDetails(descriptor_index);
   int field_index =
       map->instance_descriptors()->GetFieldIndex(descriptor_index);
   return ForPropertyIndex(map, field_index,
                           details.representation().IsDouble());
 }
 
 
@@ skipping 11 matching lines @@
     return GetLoadByFieldIndex();
   } else {
     return property_index();
   }
 }
 
 
 } }  // namespace v8::internal
 
 #endif