[Interpreter] Add support for for..in.

test/unittests/compiler/interpreter-assembler-unittest.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 "test/unittests/compiler/interpreter-assembler-unittest.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/node.h"
 #include "src/interface-descriptors.h"
@@ skipping 453 matching lines @@
     EXPECT_THAT(
         load_constant,
         m.IsLoad(kMachAnyTagged, constant_pool_matcher,
                  IsIntPtrAdd(
                      IsIntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
                      IsWordShl(index, IsInt32Constant(kPointerSizeLog2)))));
   }
 }
 
 
+TARGET_TEST_F(InterpreterAssemblerTest, LoadFixedArrayElement) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    int index = 3;
+    Node* fixed_array = m.IntPtrConstant(0xdeadbeef);
+    Node* load_element = m.LoadFixedArrayElement(fixed_array, index);
+    EXPECT_THAT(
+        load_element,
+        m.IsLoad(kMachAnyTagged, fixed_array,
+                 IsIntPtrAdd(
+                     IsIntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
+                     IsWordShl(IsInt32Constant(index),
+                               IsInt32Constant(kPointerSizeLog2)))));
+  }
+}
+
+
+TARGET_TEST_F(InterpreterAssemblerTest, LoadObjectField) {
+  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
+    InterpreterAssemblerForTest m(this, bytecode);
+    Node* object = m.IntPtrConstant(0xdeadbeef);
+    int offset = 16;
+    Node* load_field = m.LoadObjectField(object, offset);
+    EXPECT_THAT(load_field,
+                m.IsLoad(kMachAnyTagged, object,
+                         IsIntPtrConstant(offset - kHeapObjectTag)));
+  }
+}
+
+
 TARGET_TEST_F(InterpreterAssemblerTest, LoadContextSlot) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* context = m.Int32Constant(1);
     Node* slot_index = m.Int32Constant(22);
     Node* load_context_slot = m.LoadContextSlot(context, slot_index);
 
     Matcher<Node*> offset =
         IsIntPtrAdd(IsWordShl(slot_index, IsInt32Constant(kPointerSizeLog2)),
                     IsInt32Constant(Context::kHeaderSize - kHeapObjectTag));
@@ skipping 14 matching lines @@
         IsIntPtrAdd(IsWordShl(slot_index, IsInt32Constant(kPointerSizeLog2)),
                     IsInt32Constant(Context::kHeaderSize - kHeapObjectTag));
     EXPECT_THAT(
         store_context_slot,
         m.IsStore(StoreRepresentation(kMachAnyTagged, kFullWriteBarrier),
                   context, offset, value));
   }
 }
 
 
-TARGET_TEST_F(InterpreterAssemblerTest, LoadObjectField) {
-  TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
-    InterpreterAssemblerForTest m(this, bytecode);
-    Node* object = m.IntPtrConstant(0xdeadbeef);
-    int offset = 16;
-    Node* load_field = m.LoadObjectField(object, offset);
-    EXPECT_THAT(load_field,
-                m.IsLoad(kMachAnyTagged, object,
-                         IsIntPtrConstant(offset - kHeapObjectTag)));
-  }
-}
-
-
 TARGET_TEST_F(InterpreterAssemblerTest, CallRuntime2) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerForTest m(this, bytecode);
     Node* arg1 = m.Int32Constant(2);
     Node* arg2 = m.Int32Constant(3);
     Node* call_runtime = m.CallRuntime(Runtime::kAdd, arg1, arg2);
     EXPECT_THAT(call_runtime,
                 m.IsCall(_, _, arg1, arg2, _, IsInt32Constant(2),
                          IsParameter(Linkage::kInterpreterContextParameter)));
   }
@@ skipping 78 matching lines @@
         feedback_vector,
         m.IsLoad(kMachAnyTagged, load_shared_function_info_matcher,
                  IsIntPtrConstant(SharedFunctionInfo::kFeedbackVectorOffset -
                                   kHeapObjectTag)));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8