Reland 21774: Generate KeyedLoadGeneric with Hydrogen

src/heap.cc

 // 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 7691 matching lines @@
 
 
 int KeyedLookupCache::Hash(Map* map, Name* name) {
   // Uses only lower 32 bits if pointers are larger.
   uintptr_t addr_hash =
       static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map)) >> kMapHashShift;
   return static_cast<uint32_t>((addr_hash ^ name->Hash()) & kCapacityMask);
 }
 
 
+int KeyedLookupCache::ConvertToFastIndexForGeneratedCode(Map* map, int index) {
+  if (FLAG_compiled_keyed_generic_loads) {
+    if (index >= map->inobject_properties()) {
+      return -(index - map->inobject_properties() + 1);

[Toon Verwaest, 2013/12/04 17:29:26]

Seems like this should be combined with the code in
PropertyIndex::translate/is_inobject. (Why is the index here and int rather than
a PropertyIndex object?)

[danno, 2014/06/06 15:43:50]

Well, essentially because they are are not the same as the index returned from
PropertyIndex.translate(), which returns negative values for in object
properties and positive values for out-of-object. Here, we need exactly the
opposite to work out-of-the-box with HLoadIndexField, which doesn't have a map
for the size of the object and therefore can use negative values to do the math
from the end of the object dynamically.

+    }
+  }
+  return index;
+}
+
+
+int KeyedLookupCache::ConvertFromFastIndexForGeneratedCode(Map* map,
+                                                           int index) {
+  if (FLAG_compiled_keyed_generic_loads) {
+    if (index < 0) {
+      return -index + map->inobject_properties() - 1;

[Toon Verwaest, 2013/12/04 17:29:26]

Same as above.

[danno, 2014/06/06 15:43:50]

See my comment above.

+    }
+  }
+  return index;
+}
+
+
 int KeyedLookupCache::Lookup(Map* map, Name* name) {
   int index = (Hash(map, name) & kHashMask);
   for (int i = 0; i < kEntriesPerBucket; i++) {
     Key& key = keys_[index + i];
     if ((key.map == map) && key.name->Equals(name)) {
-      return field_offsets_[index + i];
+      int result = field_offsets_[index + i];
+      result = ConvertFromFastIndexForGeneratedCode(map, result);
     }
   }
   return kNotFound;
 }
 
 
 void KeyedLookupCache::Update(Map* map, Name* name, int field_offset) {
   if (!name->IsUniqueName()) {
     String* internalized_string;
     if (!map->GetIsolate()->heap()->InternalizeStringIfExists(
             String::cast(name), &internalized_string)) {
       return;
     }
     name = internalized_string;
   }
   // This cache is cleared only between mark compact passes, so we expect the
   // cache to only contain old space names.
   ASSERT(!map->GetIsolate()->heap()->InNewSpace(name));
 
+  // Swizzle the field offset so that it's in the most efficient format to be
+  // accessed in the cache from generated code: in-object properties are index
+  // offsets and out-of-object are negative offsets.
+  field_offset = ConvertToFastIndexForGeneratedCode(map, field_offset);
+
   int index = (Hash(map, name) & kHashMask);
   // After a GC there will be free slots, so we use them in order (this may
   // help to get the most frequently used one in position 0).
   for (int i = 0; i< kEntriesPerBucket; i++) {
     Key& key = keys_[index];
     Object* free_entry_indicator = NULL;
     if (key.map == free_entry_indicator) {
       key.map = map;
       key.name = name;
       field_offsets_[index + i] = field_offset;
@@ skipping 241 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   OS::MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   OS::MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal