[turbofan] Use fast stub for ForInPrepare and ForInNext

src/builtins/builtins-object.cc

 // Copyright 2016 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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/property-descriptor.h"
 
@@ skipping 892 matching lines @@
 TF_BUILTIN(ForInFilter, ObjectBuiltinsAssembler) {
   typedef ForInFilterDescriptor Descriptor;
 
   Node* key = Parameter(Descriptor::kKey);
   Node* object = Parameter(Descriptor::kObject);
   Node* context = Parameter(Descriptor::kContext);
 
   Return(ForInFilter(key, object, context));
 }
 
+TF_BUILTIN(ForInNext, ObjectBuiltinsAssembler) {
+  typedef ForInNextDescriptor Descriptor;
+
+  Label filter(this);
+  Node* object = Parameter(Descriptor::kObject);
+  Node* cache_array = Parameter(Descriptor::kCacheArray);
+  Node* cache_type = Parameter(Descriptor::kCacheType);
+  Node* index = Parameter(Descriptor::kIndex);
+  Node* context = Parameter(Descriptor::kContext);
+
+  Node* key = LoadFixedArrayElement(cache_array, SmiUntag(index));
+  Node* map = LoadMap(object);
+  GotoUnless(WordEqual(map, cache_type), &filter);
+  Return(key);
+  Bind(&filter);
+  Return(ForInFilter(key, object, context));
+}
+
+TF_BUILTIN(ForInPrepare, ObjectBuiltinsAssembler) {
+  typedef ForInPrepareDescriptor Descriptor;
+
+  Label use_cache(this), nothing_to_iterate(this), call_runtime(this);
+  Node* object = Parameter(Descriptor::kObject);
+  Node* context = Parameter(Descriptor::kContext);
+
+  CheckEnumCache(object, &use_cache, &call_runtime);
+  Bind(&use_cache);
+  Node* map = LoadMap(object);
+  Node* enum_length = EnumLength(map);
+  GotoIf(WordEqual(enum_length, SmiConstant(0)), &nothing_to_iterate);
+  Node* descriptors = LoadMapDescriptors(map);
+  Node* cache_offset =
+      LoadObjectField(descriptors, DescriptorArray::kEnumCacheOffset);
+  Node* enum_cache = LoadObjectField(
+      cache_offset, DescriptorArray::kEnumCacheBridgeCacheOffset);
+  Return(map, enum_cache, enum_length);
+
+  Bind(&nothing_to_iterate);
+  Node* zero = SmiConstant(0);
+  Return(zero, zero, zero);
+
+  Bind(&call_runtime);
+  TailCallRuntime(Runtime::kForInPrepare, context, object);

[rmcilroy, 2017/02/08 23:37:22]

Could we use this same code (inlined) in Interpreter::DoForInPrepare and / or
move some of the logic there in here, and then share it between the interpreter
and the builtin ?  (ditto with ForInNext).

[Camillo Bruni, 2017/02/09 10:25:05]

I spent too much time chatting with people yesterday, but I planned to do that
cleanup as well for ignition :P

+}
+
 TF_BUILTIN(InstanceOf, ObjectBuiltinsAssembler) {
   typedef CompareDescriptor Descriptor;
 
   Node* object = Parameter(Descriptor::kLeft);
   Node* callable = Parameter(Descriptor::kRight);
   Node* context = Parameter(Descriptor::kContext);
 
   Return(InstanceOf(object, callable, context));
 }
 
@@ skipping 12 matching lines @@
   typedef TypeofDescriptor Descriptor;
 
   Node* object = Parameter(Descriptor::kObject);
   Node* context = Parameter(Descriptor::kContext);
 
   Return(GetSuperConstructor(object, context));
 }
 
 }  // namespace internal
 }  // namespace v8