[Interpreter] Assign feedback slots for binary operations and use them in ignition.

test/cctest/interpreter/test-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/v8.h"
 
 #include "src/execution.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/bytecode-array-iterator.h"
@@ skipping 249 matching lines @@
 }
 
 
 TEST(InterpreterShiftOpsSmi) {
   int lhs_inputs[] = {0, -17, -182, 1073741823, -1};
   int rhs_inputs[] = {5, 2, 1, -1, -2, 0, 31, 32, -32, 64, 37};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kShiftOperators); o++) {
         HandleAndZoneScope handles;
-        i::Factory* factory = handles.main_isolate()->factory();
+        i::Isolate* isolate = handles.main_isolate();
+        i::Factory* factory = isolate->factory();
+        i::Zone zone(isolate->allocator());
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone(), 1, 0, 1);
+
+        i::FeedbackVectorSpec feedback_spec(&zone);
+        i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+        Handle<i::TypeFeedbackVector> vector =
+            i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
-            .BinaryOperation(kShiftOperators[o], reg)
+            .BinaryOperation(kShiftOperators[o], reg, vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kShiftOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
 
 TEST(InterpreterBinaryOpsSmi) {
   int lhs_inputs[] = {3266, 1024, 0, -17, -18000};
   int rhs_inputs[] = {3266, 5, 4, 3, 2, 1, -1, -2};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
-        i::Factory* factory = handles.main_isolate()->factory();
+        i::Isolate* isolate = handles.main_isolate();
+        i::Factory* factory = isolate->factory();
+        i::Zone zone(isolate->allocator());
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone(), 1, 0, 1);
 
+        i::FeedbackVectorSpec feedback_spec(&zone);
+        i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+        Handle<i::TypeFeedbackVector> vector =
+            i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
         Register reg(0);
         int lhs = lhs_inputs[l];
         int rhs = rhs_inputs[r];
         builder.LoadLiteral(Smi::FromInt(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(Smi::FromInt(rhs))
-            .BinaryOperation(kArithmeticOperators[o], reg)
+            .BinaryOperation(kArithmeticOperators[o], reg,
+                             vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
 
 TEST(InterpreterBinaryOpsHeapNumber) {
   double lhs_inputs[] = {3266.101, 1024.12, 0.01, -17.99, -18000.833, 9.1e17};
   double rhs_inputs[] = {3266.101, 5.999, 4.778, 3.331,  2.643,
                          1.1,      -1.8,  -2.9,  8.3e-27};
   for (size_t l = 0; l < arraysize(lhs_inputs); l++) {
     for (size_t r = 0; r < arraysize(rhs_inputs); r++) {
       for (size_t o = 0; o < arraysize(kArithmeticOperators); o++) {
         HandleAndZoneScope handles;
-        i::Factory* factory = handles.main_isolate()->factory();
+        i::Isolate* isolate = handles.main_isolate();
+        i::Factory* factory = isolate->factory();
+        i::Zone zone(isolate->allocator());
         BytecodeArrayBuilder builder(handles.main_isolate(),
                                      handles.main_zone(), 1, 0, 1);
+
+        i::FeedbackVectorSpec feedback_spec(&zone);
+        i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+        Handle<i::TypeFeedbackVector> vector =
+            i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
         Register reg(0);
         double lhs = lhs_inputs[l];
         double rhs = rhs_inputs[r];
         builder.LoadLiteral(factory->NewNumber(lhs))
             .StoreAccumulatorInRegister(reg)
             .LoadLiteral(factory->NewNumber(rhs))
-            .BinaryOperation(kArithmeticOperators[o], reg)
+            .BinaryOperation(kArithmeticOperators[o], reg,
+                             vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
         InterpreterTester tester(handles.main_isolate(), bytecode_array);
         auto callable = tester.GetCallable<>();
         Handle<Object> return_value = callable().ToHandleChecked();
         Handle<Object> expected_value =
             factory->NewNumber(BinaryOpC(kArithmeticOperators[o], lhs, rhs));
         CHECK(return_value->SameValue(*expected_value));
       }
     }
   }
 }
 
 
 TEST(InterpreterStringAdd) {
   HandleAndZoneScope handles;
-  i::Factory* factory = handles.main_isolate()->factory();
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+  i::Zone zone(isolate->allocator());
 
   struct TestCase {
     Handle<Object> lhs;
     Handle<Object> rhs;
     Handle<Object> expected_value;
   } test_cases[] = {
       {factory->NewStringFromStaticChars("a"),
        factory->NewStringFromStaticChars("b"),
        factory->NewStringFromStaticChars("ab")},
       {factory->NewStringFromStaticChars("aaaaaa"),
@@ skipping 12 matching lines @@
        factory->NewStringFromStaticChars("1.112.5")},
       {factory->NewStringFromStaticChars("-1.11"), factory->NewHeapNumber(2.56),
        factory->NewStringFromStaticChars("-1.112.56")},
       {factory->NewStringFromStaticChars(""), factory->NewHeapNumber(2.5),
        factory->NewStringFromStaticChars("2.5")},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); i++) {
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
                                  0, 1);
+    i::FeedbackVectorSpec feedback_spec(&zone);
+    i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+    Handle<i::TypeFeedbackVector> vector =
+        i::NewTypeFeedbackVector(isolate, &feedback_spec);
 
     Register reg(0);
     builder.LoadLiteral(test_cases[i].lhs)
         .StoreAccumulatorInRegister(reg)
         .LoadLiteral(test_cases[i].rhs)
-        .BinaryOperation(Token::Value::ADD, reg)
+        .BinaryOperation(Token::Value::ADD, reg, vector->GetIndex(slot))
         .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*test_cases[i].expected_value));
   }
 }
 
@@ skipping 16 matching lines @@
 
   // Check for Smis.
   return_val = callable(Handle<Smi>(Smi::FromInt(3), handles.main_isolate()))
                    .ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(3));
 }
 
 
 TEST(InterpreterParameter8) {
   HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Zone zone(isolate->allocator());
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 8,
                                0, 0);
 
+  i::FeedbackVectorSpec feedback_spec(&zone);
+  i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot1 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot2 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot3 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot4 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot5 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot6 = feedback_spec.AddGeneralSlot();
+
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
   builder.LoadAccumulatorWithRegister(builder.Parameter(0))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(1))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(2))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(3))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(4))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(5))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(6))
-      .BinaryOperation(Token::Value::ADD, builder.Parameter(7))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(1),
+                       vector->GetIndex(slot))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(2),
+                       vector->GetIndex(slot1))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(3),
+                       vector->GetIndex(slot2))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(4),
+                       vector->GetIndex(slot3))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(5),
+                       vector->GetIndex(slot4))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(6),
+                       vector->GetIndex(slot5))
+      .BinaryOperation(Token::Value::ADD, builder.Parameter(7),
+                       vector->GetIndex(slot6))
       .Return();
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   typedef Handle<Object> H;
   auto callable = tester.GetCallable<H, H, H, H, H, H, H, H>();
 
   Handle<Smi> arg1 = Handle<Smi>(Smi::FromInt(1), handles.main_isolate());
   Handle<Smi> arg2 = Handle<Smi>(Smi::FromInt(2), handles.main_isolate());
   Handle<Smi> arg3 = Handle<Smi>(Smi::FromInt(3), handles.main_isolate());
@@ skipping 487 matching lines @@
 
 static BytecodeArrayBuilder& SetRegister(BytecodeArrayBuilder& builder,
                                          Register reg, int value,
                                          Register scratch) {
   return builder.StoreAccumulatorInRegister(scratch)
       .LoadLiteral(Smi::FromInt(value))
       .StoreAccumulatorInRegister(reg)
       .LoadAccumulatorWithRegister(scratch);
 }
 
-
 static BytecodeArrayBuilder& IncrementRegister(BytecodeArrayBuilder& builder,
                                                Register reg, int value,
-                                               Register scratch) {
+                                               Register scratch,
+                                               int slot_index) {
   return builder.StoreAccumulatorInRegister(scratch)
       .LoadLiteral(Smi::FromInt(value))
-      .BinaryOperation(Token::Value::ADD, reg)
+      .BinaryOperation(Token::Value::ADD, reg, slot_index)
       .StoreAccumulatorInRegister(reg)
       .LoadAccumulatorWithRegister(scratch);
 }
 
 
 TEST(InterpreterJumps) {
   HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Zone zone(isolate->allocator());
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
                                0, 2);
 
+  i::FeedbackVectorSpec feedback_spec(&zone);
+  i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot1 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot2 = feedback_spec.AddGeneralSlot();
+
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
   Register reg(0), scratch(1);
   BytecodeLabel label[3];
 
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .Jump(&label[1]);
   SetRegister(builder, reg, 1024, scratch).Bind(&label[0]);
-  IncrementRegister(builder, reg, 1, scratch).Jump(&label[2]);
+  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot))
+      .Jump(&label[2]);
   SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch).Jump(&label[0]);
+  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot1))
+      .Jump(&label[0]);
   SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
-  IncrementRegister(builder, reg, 4, scratch)
+  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot2))
       .LoadAccumulatorWithRegister(reg)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 
 TEST(InterpreterConditionalJumps) {
   HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Zone zone(isolate->allocator());
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
                                0, 2);
 
+  i::FeedbackVectorSpec feedback_spec(&zone);
+  i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot1 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot2 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot3 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot4 = feedback_spec.AddGeneralSlot();
+
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
-  IncrementRegister(builder, reg, 1024, scratch)
+  IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
-  IncrementRegister(builder, reg, 1, scratch).LoadTrue().JumpIfTrue(&label[1]);
-  IncrementRegister(builder, reg, 2048, scratch).Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch).LoadFalse().JumpIfTrue(&done1);
-  IncrementRegister(builder, reg, 4, scratch)
+  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
+      .LoadTrue()
+      .JumpIfTrue(&label[1]);
+  IncrementRegister(builder, reg, 2048, scratch, vector->GetIndex(slot2))
+      .Bind(&label[1]);
+  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot3))
+      .LoadFalse()
+      .JumpIfTrue(&done1);
+  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot4))
       .LoadAccumulatorWithRegister(reg)
       .Bind(&done)
       .Bind(&done1)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 TEST(InterpreterConditionalJumps2) {
   // TODO(oth): Add tests for all conditional jumps near and far.
   HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Zone zone(isolate->allocator());
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 0,
                                0, 2);
 
+  i::FeedbackVectorSpec feedback_spec(&zone);
+  i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot1 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot2 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot3 = feedback_spec.AddGeneralSlot();
+  i::FeedbackVectorSlot slot4 = feedback_spec.AddGeneralSlot();
+
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
   Register reg(0), scratch(1);
   BytecodeLabel label[2];
   BytecodeLabel done, done1;
 
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .JumpIfFalse(&label[0]);
-  IncrementRegister(builder, reg, 1024, scratch)
+  IncrementRegister(builder, reg, 1024, scratch, vector->GetIndex(slot))
       .Bind(&label[0])
       .LoadTrue()
       .JumpIfFalse(&done);
-  IncrementRegister(builder, reg, 1, scratch).LoadTrue().JumpIfTrue(&label[1]);
-  IncrementRegister(builder, reg, 2048, scratch).Bind(&label[1]);
-  IncrementRegister(builder, reg, 2, scratch).LoadFalse().JumpIfTrue(&done1);
-  IncrementRegister(builder, reg, 4, scratch)
+  IncrementRegister(builder, reg, 1, scratch, vector->GetIndex(slot1))
+      .LoadTrue()
+      .JumpIfTrue(&label[1]);
+  IncrementRegister(builder, reg, 2048, scratch, vector->GetIndex(slot2))
+      .Bind(&label[1]);
+  IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot3))
+      .LoadFalse()
+      .JumpIfTrue(&done1);
+  IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot4))
       .LoadAccumulatorWithRegister(reg)
       .Bind(&done)
       .Bind(&done1)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
   InterpreterTester tester(handles.main_isolate(), bytecode_array);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 TEST(InterpreterJumpConstantWith16BitOperand) {
   HandleAndZoneScope handles;
   BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
                                0, 257);
 
+  i::Isolate* isolate = handles.main_isolate();
+  i::Zone zone(isolate->allocator());
+
+  i::FeedbackVectorSpec feedback_spec(&zone);
+  i::FeedbackVectorSlot slot = feedback_spec.AddGeneralSlot();
+  Handle<i::TypeFeedbackVector> vector =
+      i::NewTypeFeedbackVector(isolate, &feedback_spec);
+
   Register reg(0), scratch(256);
   BytecodeLabel done, fake;
 
   builder.LoadLiteral(Smi::FromInt(0));
   builder.StoreAccumulatorInRegister(reg);
   // Consume all 8-bit operands
   for (int i = 1; i <= 256; i++) {
     builder.LoadLiteral(handles.main_isolate()->factory()->NewNumber(i));
-    builder.BinaryOperation(Token::Value::ADD, reg);
+    builder.BinaryOperation(Token::Value::ADD, reg, vector->GetIndex(slot));
     builder.StoreAccumulatorInRegister(reg);
   }
   builder.Jump(&done);
 
   // Emit more than 16-bit immediate operands worth of code to jump over.
   builder.Bind(&fake);
   for (int i = 0; i < 6600; i++) {
     builder.LoadLiteral(Smi::FromInt(0));                 // 1-byte
-    builder.BinaryOperation(Token::Value::ADD, scratch);  // 4-bytes
+    builder.BinaryOperation(Token::Value::ADD, scratch,
+                            vector->GetIndex(slot));      // 6-bytes
     builder.StoreAccumulatorInRegister(scratch);          // 4-bytes
     builder.MoveRegister(scratch, reg);                   // 6-bytes
   }
   builder.Bind(&done);
   builder.LoadAccumulatorWithRegister(reg);
   builder.Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
   BytecodeArrayIterator iterator(bytecode_array);
 
@@ skipping 3108 matching lines @@
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*tests[i].second));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8