[interpreter] Update ForInPrepare to conditionally use runtime.

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 
 #include "src/ast/prettyprinter.h"
 #include "src/code-factory.h"
@@ skipping 1822 matching lines @@
   void Interpreter::Do##Name(InterpreterAssembler* assembler) {               \
     Node* context = __ GetContext();                                          \
     Node* accumulator = __ GetAccumulator();                                  \
     Node* original_handler =                                                  \
         __ CallRuntime(Runtime::kDebugBreakOnBytecode, context, accumulator); \
     __ DispatchToBytecodeHandler(original_handler);                           \
   }
 DEBUG_BREAK_BYTECODE_LIST(DEBUG_BREAK);
 #undef DEBUG_BREAK
 
+void Interpreter::BuildForInPrepareResult(Node* output_register,
+                                          Node* cache_type, Node* cache_array,
+                                          Node* cache_length,
+                                          InterpreterAssembler* assembler) {
+  __ StoreRegister(cache_type, output_register);
+  output_register = __ NextRegister(output_register);
+  __ StoreRegister(cache_array, output_register);
+  output_register = __ NextRegister(output_register);
+  __ StoreRegister(cache_length, output_register);
+}
+
 // ForInPrepare <cache_info_triple>
 //
 // Returns state for for..in loop execution based on the object in the
 // accumulator. The result is output in registers |cache_info_triple| to
 // |cache_info_triple + 2|, with the registers holding cache_type, cache_array,
 // and cache_length respectively.
 void Interpreter::DoForInPrepare(InterpreterAssembler* assembler) {
   Node* object = __ GetAccumulator();
   Node* context = __ GetContext();
-  Node* result_triple = __ CallRuntime(Runtime::kForInPrepare, context, object);
+  Node* const zero_smi = __ SmiConstant(Smi::FromInt(0));
 
-  // Set output registers:
-  //   0 == cache_type, 1 == cache_array, 2 == cache_length
-  Node* output_register = __ BytecodeOperandReg(0);
-  for (int i = 0; i < 3; i++) {
-    Node* cache_info = __ Projection(i, result_triple);
-    __ StoreRegister(cache_info, output_register);
-    output_register = __ NextRegister(output_register);
+  Label test_if_null(assembler), test_if_undefined(assembler),
+      nothing_to_iterate(assembler, Label::kDeferred),

[rmcilroy, 2016/07/19 11:08:54]

Just wondering if nothing_to_iterate should be kDeferred? It doesn't involve a
call (so doesn't cause the fast-path to build a frame), but is probably not a
common occurrence, so might still be worth being deferred. Was there a reason it
was made deferred?

[oth, 2016/07/19 12:59:25]

I expect this is the lesser trodden path - it's deferred to reduce the sharing
i-cache entries that are used more frequently.

+      convert_to_receiver(assembler), already_receiver(assembler),
+      check_enum_cache(assembler);
+
+  Variable receiver(assembler, MachineRepresentation::kTagged);
+
+  // Test if object is already a receiver, no conversion necessary if so.
+  Node* instance_type = __ LoadInstanceType(object);
+  Node* first_receiver_type = __ Int32Constant(FIRST_JS_RECEIVER_TYPE);
+  __ BranchIf(
+      assembler->Int32GreaterThanOrEqual(instance_type, first_receiver_type),

[rmcilroy, 2016/07/19 11:08:54]

There is a BranchIfInt32GreaterThanOrEqual (I think).

[oth, 2016/07/19 12:59:25]

Thanks! Done.

+      &already_receiver, &test_if_null);
+
+  __ Bind(&test_if_null);
+  {
+    __ BranchIf(assembler->WordEqual(object, assembler->NullConstant()),

[rmcilroy, 2016/07/19 11:08:54]

BranchIfWordEqual (and below)

[oth, 2016/07/19 12:59:25]

Done.

+                &nothing_to_iterate, &test_if_undefined);
   }
-  __ Dispatch();
+
+  __ Bind(&test_if_undefined);
+  {
+    __ BranchIf(assembler->WordEqual(object, assembler->UndefinedConstant()),
+                &nothing_to_iterate, &convert_to_receiver);
+  }
+
+  __ Bind(&convert_to_receiver);

[rmcilroy, 2016/07/19 11:08:54]

I'm assuming this is relatively uncommon. If so, could this be kDeferred? That
might allow us to avoid building a frame in the fast-path.

[oth, 2016/07/19 12:59:25]

Done.

+  {
+    Callable callable = CodeFactory::ToObject(assembler->isolate());
+    Node* target = __ HeapConstant(callable.code());
+    Node* result = __ CallStub(callable.descriptor(), target, context, object);
+    receiver.Bind(result);
+    __ Goto(&check_enum_cache);
+  }
+
+  __ Bind(&already_receiver);
+  {
+    receiver.Bind(object);
+    __ Goto(&check_enum_cache);
+  }
+
+  Label use_enum_cache(assembler), use_runtime(assembler);

[rmcilroy, 2016/07/19 11:08:54]

make use_runtime kDeferred.

[oth, 2016/07/19 12:59:25]

Done.

+  __ Bind(&check_enum_cache);
+  { __ CheckEnumCache(receiver.value(), &use_enum_cache, &use_runtime); }
+
+  __ Bind(&use_enum_cache);
+  {
+    // The enum cache is valid.  Load the map of the object being
+    // iterated over and use the cache for the iteration.
+    Node* cache_type = __ LoadMap(receiver.value());
+    Node* cache_length = __ EnumLength(cache_type);
+    __ GotoIf(assembler->WordEqual(cache_length, zero_smi),
+              &nothing_to_iterate);
+    Node* descriptors = __ LoadMapDescriptors(cache_type);
+    Node* cache_offset =
+        __ LoadObjectField(descriptors, DescriptorArray::kEnumCacheOffset);
+    Node* cache_array = __ LoadObjectField(
+        cache_offset, DescriptorArray::kEnumCacheBridgeCacheOffset);
+    Node* output_register = __ BytecodeOperandReg(0);
+    BuildForInPrepareResult(output_register, cache_type, cache_array,
+                            cache_length, assembler);
+    __ Dispatch();
+  }
+
+  __ Bind(&use_runtime);
+  {
+    Node* result_triple =
+        __ CallRuntime(Runtime::kForInPrepare, context, object);
+    Node* cache_type = __ Projection(0, result_triple);
+    Node* cache_array = __ Projection(1, result_triple);
+    Node* cache_length = __ Projection(2, result_triple);
+    Node* output_register = __ BytecodeOperandReg(0);
+    BuildForInPrepareResult(output_register, cache_type, cache_array,
+                            cache_length, assembler);
+    __ Dispatch();
+  }
+
+  __ Bind(&nothing_to_iterate);
+  {
+    // Receiver is null or undefined or descriptors are zero length.
+    Node* output_register = __ BytecodeOperandReg(0);
+    BuildForInPrepareResult(output_register, zero_smi, zero_smi, zero_smi,
+                            assembler);
+    __ Dispatch();
+  }
 }
 
 // ForInNext <receiver> <index> <cache_info_pair>
 //
 // Returns the next enumerable property in the the accumulator.
 void Interpreter::DoForInNext(InterpreterAssembler* assembler) {
   Node* receiver_reg = __ BytecodeOperandReg(0);
   Node* receiver = __ LoadRegister(receiver_reg);
   Node* index_reg = __ BytecodeOperandReg(1);
   Node* index = __ LoadRegister(index_reg);
@@ skipping 162 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8