[interpreter] Make the binary op with Smi bytecode handlers collect type feedback.

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 263 matching lines @@
         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, vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array);
+        InterpreterTester tester(isolate, bytecode_array, vector);
         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));
       }
     }
   }
 }
 
@@ skipping 19 matching lines @@
         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,
                              vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array);
+        InterpreterTester tester(isolate, bytecode_array, vector);
         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));
       }
     }
   }
 }
 
@@ skipping 20 matching lines @@
         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,
                              vector->GetIndex(slot))
             .Return();
         Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
 
-        InterpreterTester tester(isolate, bytecode_array);
+        InterpreterTester tester(isolate, bytecode_array, vector);
         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));
       }
     }
   }
 }
 
@@ skipping 126 matching lines @@
   Handle<Smi> arg6 = Handle<Smi>(Smi::FromInt(6), handles.main_isolate());
   Handle<Smi> arg7 = Handle<Smi>(Smi::FromInt(7), handles.main_isolate());
   Handle<Smi> arg8 = Handle<Smi>(Smi::FromInt(8), handles.main_isolate());
   // Check for Smis.
   Handle<Object> return_val =
       callable(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
           .ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(36));
 }
 
 TEST(InterpreterBinaryOpTypeFeedback) {

[rmcilroy, 2016/08/23 10:28:53]

Could you add a variant of these tests which take immediate RHS operands to test
the feedback progression of Add/SubSmi bytecodes.

[epertoso, 2016/08/23 13:24:28]

Done.

   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Zone zone(isolate->allocator());
 
   struct BinaryOpExpectation {
     Token::Value op;
     Handle<Object> arg1;
     Handle<Object> arg2;
     Handle<Object> result;
     int32_t feedback;
@@ skipping 202 matching lines @@
     CHECK_EQ(BinaryOperationFeedback::kNumber,
              static_cast<Smi*>(feedback2)->value());
 
     Object* feedback3 = vector->Get(slot3);
     CHECK(feedback3->IsSmi());
     CHECK_EQ(BinaryOperationFeedback::kAny,
              static_cast<Smi*>(feedback3)->value());
   }
 }
 
 TEST(InterpreterBitwiseTypeFeedback) {

[rmcilroy, 2016/08/23 10:28:53]

Ditto with the bitwise SMI variants.

[epertoso, 2016/08/23 13:24:28]

Done.

   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Zone zone(isolate->allocator());
   const Token::Value kBitwiseBinaryOperators[] = {
       Token::Value::BIT_OR, Token::Value::BIT_XOR, Token::Value::BIT_AND,
       Token::Value::SHL,    Token::Value::SHR,     Token::Value::SAR};
 
   for (Token::Value op : kBitwiseBinaryOperators) {
     BytecodeArrayBuilder builder(isolate, handles.main_zone(), 4, 0, 0);
 
@@ skipping 558 matching lines @@
       .Jump(&label[2]);
   SetRegister(builder, reg, 2048, scratch).Bind(&label[1]);
   IncrementRegister(builder, reg, 2, scratch, vector->GetIndex(slot1))
       .Jump(&label[0]);
   SetRegister(builder, reg, 4096, scratch).Bind(&label[2]);
   IncrementRegister(builder, reg, 4, scratch, vector->GetIndex(slot2))
       .LoadAccumulatorWithRegister(reg)
       .Return();
 
   Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray(isolate);
-  InterpreterTester tester(isolate, bytecode_array);
+  InterpreterTester tester(isolate, bytecode_array, vector);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 
 TEST(InterpreterConditionalJumps) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   Zone zone(isolate->allocator());
@@ skipping 29 matching lines @@
   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(isolate);
-  InterpreterTester tester(isolate, bytecode_array);
+  InterpreterTester tester(isolate, bytecode_array, vector);
   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;
   Isolate* isolate = handles.main_isolate();
   Zone zone(isolate->allocator());
@@ skipping 29 matching lines @@
   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(isolate);
-  InterpreterTester tester(isolate, bytecode_array);
+  InterpreterTester tester(isolate, bytecode_array, vector);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 7);
 }
 
 TEST(InterpreterJumpConstantWith16BitOperand) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 257);
 
@@ skipping 37 matching lines @@
   while (!iterator.done()) {
     if (iterator.current_bytecode() == Bytecode::kJumpConstant &&
         iterator.current_operand_scale() == OperandScale::kDouble) {
       found_16bit_constant_jump = true;
       break;
     }
     iterator.Advance();
   }
   CHECK(found_16bit_constant_jump);
 
-  InterpreterTester tester(isolate, bytecode_array);
+  InterpreterTester tester(isolate, bytecode_array, vector);
   auto callable = tester.GetCallable<>();
   Handle<Object> return_value = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_value)->value(), 256.0 / 2 * (1 + 256));
 }
 
 TEST(InterpreterJumpWith32BitOperand) {
   HandleAndZoneScope handles;
   Isolate* isolate = handles.main_isolate();
   BytecodeArrayBuilder builder(isolate, handles.main_zone(), 1, 0, 1);
   Register reg(0);
@@ skipping 3093 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