[builtins] Migrate Object.keys to CodeStubAssembler builtin.

src/keys.cc

 // Copyright 2013 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.
 
 #include "src/keys.h"
 
 #include "src/api-arguments.h"
 #include "src/elements.h"
 #include "src/factory.h"
 #include "src/identity-map.h"
@@ skipping 29 matching lines @@
   FastKeyAccumulator accumulator(isolate, object, mode, filter);
   accumulator.set_is_for_in(is_for_in);
   return accumulator.GetKeys(keys_conversion);
 }
 
 Handle<FixedArray> KeyAccumulator::GetKeys(GetKeysConversion convert) {
   if (keys_.is_null()) {
     return isolate_->factory()->empty_fixed_array();
   }
   if (mode_ == KeyCollectionMode::kOwnOnly &&
-      keys_->map() == isolate_->heap()->fixed_array_map()) {
+      (keys_->map() == isolate_->heap()->fixed_array_map() ||
+       keys_->map() == isolate_->heap()->fixed_cow_array_map())) {
     return Handle<FixedArray>::cast(keys_);
   }
   USE(ContainsOnlyValidKeys);
   Handle<FixedArray> result =
       OrderedHashSet::ConvertToKeysArray(keys(), convert);
   DCHECK(ContainsOnlyValidKeys(result));
   return result;
 }
 
 void KeyAccumulator::AddKey(Object* key, AddKeyConversion convert) {
@@ skipping 195 matching lines @@
   if (has_empty_prototype_) {
     is_receiver_simple_enum_ =
         receiver_->map()->EnumLength() != kInvalidEnumCacheSentinel &&
         !JSObject::cast(*receiver_)->HasEnumerableElements();
   } else if (last_prototype != nullptr) {
     last_non_empty_prototype_ = handle(last_prototype, isolate_);
   }
 }
 
 namespace {
-static Handle<FixedArray> ReduceFixedArrayTo(Isolate* isolate,
-                                             Handle<FixedArray> array,
-                                             int length) {
+
+Handle<FixedArray> ReduceFixedArrayTo(Isolate* isolate,
+                                      Handle<FixedArray> array, int length) {
   DCHECK_LE(length, array->length());
   if (array->length() == length) return array;
   return isolate->factory()->CopyFixedArrayUpTo(array, length);
 }
 
 // Initializes and directly returns the enume cache. Users of this function
 // have to make sure to never directly leak the enum cache.
 Handle<FixedArray> GetFastEnumPropertyKeys(Isolate* isolate,
                                            Handle<JSObject> object) {
   Handle<Map> map(object->map());
@@ skipping 29 matching lines @@
   }
 
   if (descs->IsEmpty()) {
     isolate->counters()->enum_cache_hits()->Increment();
     if (cache_enum_length) map->SetEnumLength(0);
     return isolate->factory()->empty_fixed_array();
   }
 
   isolate->counters()->enum_cache_misses()->Increment();
 
-  Handle<FixedArray> storage =
-      isolate->factory()->NewFixedArray(own_property_count);
-  Handle<FixedArray> indices =
-      isolate->factory()->NewFixedArray(own_property_count);
+  Handle<FixedArray> storage = isolate->factory()->empty_fixed_array();
+  Handle<FixedArray> indices = isolate->factory()->empty_fixed_array();
+  if (own_property_count != 0) {
+    storage = isolate->factory()->NewFixedArray(own_property_count);
+    indices = isolate->factory()->NewFixedArray(own_property_count);
 
-  int size = map->NumberOfOwnDescriptors();
-  int index = 0;
+    int size = map->NumberOfOwnDescriptors();
+    int index = 0;
 
-  for (int i = 0; i < size; i++) {
-    PropertyDetails details = descs->GetDetails(i);
-    if (details.IsDontEnum()) continue;
-    Object* key = descs->GetKey(i);
-    if (key->IsSymbol()) continue;
-    storage->set(index, key);
-    if (!indices.is_null()) {
-      if (details.location() == kField) {
-        DCHECK_EQ(kData, details.kind());
-        FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
-        int load_by_field_index = field_index.GetLoadByFieldIndex();
-        indices->set(index, Smi::FromInt(load_by_field_index));
-      } else {
-        indices = Handle<FixedArray>();
+    for (int i = 0; i < size; i++) {
+      PropertyDetails details = descs->GetDetails(i);
+      if (details.IsDontEnum()) continue;
+      Object* key = descs->GetKey(i);
+      if (key->IsSymbol()) continue;
+      storage->set(index, key);
+      if (!indices.is_null()) {
+        if (details.location() == kField) {
+          DCHECK_EQ(kData, details.kind());
+          FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
+          int load_by_field_index = field_index.GetLoadByFieldIndex();
+          indices->set(index, Smi::FromInt(load_by_field_index));
+        } else {
+          indices = Handle<FixedArray>();
+        }
       }
+      index++;
     }
-    index++;
+    DCHECK_EQ(index, storage->length());
+
+    // Mark the {storage} as copy-on-write, so we can use this
+    // as JSArray elements backing store directly w/o copying.
+    storage->set_map(isolate->heap()->fixed_cow_array_map());
   }
-  DCHECK(index == storage->length());
 
   DescriptorArray::SetEnumCache(descs, isolate, storage, indices);
   if (cache_enum_length) {
     map->SetEnumLength(own_property_count);
   }
   return storage;
 }
 
 template <bool fast_properties>
 MaybeHandle<FixedArray> GetOwnKeysWithElements(Isolate* isolate,
@@ skipping 80 matching lines @@
     // Assume that there are elements.
     return MaybeHandle<FixedArray>();
   }
   int number_of_own_descriptors = map->NumberOfOwnDescriptors();
   if (number_of_own_descriptors == 0) {
     map->SetEnumLength(0);
     return isolate_->factory()->empty_fixed_array();
   }
   // We have no elements but possibly enumerable property keys, hence we can
   // directly initialize the enum cache.
-  Handle<FixedArray> keys = GetFastEnumPropertyKeys(isolate_, object);
-  if (is_for_in_) return keys;
-  // Do not leak the enum cache as it might end up as an elements backing store.
-  return isolate_->factory()->CopyFixedArray(keys);
+  return GetFastEnumPropertyKeys(isolate_, object);
 }
 
 MaybeHandle<FixedArray> FastKeyAccumulator::GetKeysSlow(
     GetKeysConversion keys_conversion) {
   KeyAccumulator accumulator(isolate_, mode_, filter_);
   accumulator.set_is_for_in(is_for_in_);
   accumulator.set_last_non_empty_prototype(last_non_empty_prototype_);
 
   MAYBE_RETURN(accumulator.CollectKeys(receiver_, receiver_),
                MaybeHandle<FixedArray>());
@@ skipping 424 matching lines @@
       isolate_, keys,
       KeyAccumulator::GetKeys(target, KeyCollectionMode::kOwnOnly, filter_,
                               GetKeysConversion::kConvertToString, is_for_in_),
       Nothing<bool>());
   Maybe<bool> result = AddKeysFromJSProxy(proxy, keys);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8