[interpreter] Introduce binary op bytecodes for Smi operand.

test/unittests/interpreter/bytecode-array-builder-unittest.cc

 // Copyright 2014 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/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-label.h"
 #include "src/interpreter/bytecode-register-allocator.h"
@@ skipping 24 matching lines @@
 
   // Emit argument creation operations.
   builder.CreateArguments(CreateArgumentsType::kMappedArguments)
       .CreateArguments(CreateArgumentsType::kUnmappedArguments)
       .CreateArguments(CreateArgumentsType::kRestParameter);
 
   // Emit constant loads.
   builder.LoadLiteral(Smi::FromInt(0))
       .StoreAccumulatorInRegister(reg)
       .LoadLiteral(Smi::FromInt(8))
+      .CompareOperation(Token::Value::NE, reg)  // Prevent peephole optimization
+                                                // LdaSmi, Star -> LdrSmi.
       .StoreAccumulatorInRegister(reg)
       .LoadLiteral(Smi::FromInt(10000000))
       .StoreAccumulatorInRegister(reg)
       .LoadLiteral(factory->NewStringFromStaticChars("A constant"))
       .StoreAccumulatorInRegister(reg)
       .LoadUndefined()
       .Debugger()  // Prevent peephole optimization LdaNull, Star -> LdrNull.
       .LoadNull()
       .StoreAccumulatorInRegister(reg)
       .LoadTheHole()
       .StoreAccumulatorInRegister(reg)
       .LoadTrue()
       .StoreAccumulatorInRegister(reg)
       .LoadFalse()
       .StoreAccumulatorInRegister(wide);
 
   // Emit Ldar and Star taking care to foil the register optimizer.
   builder.StackCheck(0)
       .LoadAccumulatorWithRegister(other)
       .BinaryOperation(Token::ADD, reg)
       .StoreAccumulatorInRegister(reg)
       .LoadNull();
 
+  // Force emission of AddSmi.

[rmcilroy, 2016/07/04 12:35:32]

nit - maybe just group these all together since they are simlar peephole
operations?

[oth, 2016/07/04 14:56:24]

Done.

+  builder.LoadLiteral(Smi::FromInt(1)).BinaryOperation(Token::Value::ADD, reg);
+
+  // Force emission of SubSmi.
+  builder.LoadLiteral(Smi::FromInt(1)).BinaryOperation(Token::Value::SUB, reg);
+
   // Emit register-register transfer.
   builder.MoveRegister(reg, other);
   builder.MoveRegister(reg, wide);
 
   // Emit global load / store operations.
   Handle<String> name = factory->NewStringFromStaticChars("var_name");
   builder.LoadGlobal(1, TypeofMode::NOT_INSIDE_TYPEOF)
       .LoadGlobal(1, TypeofMode::INSIDE_TYPEOF)
       .StoreGlobal(name, 1, LanguageMode::SLOPPY)
       .StoreGlobal(name, 1, LanguageMode::STRICT);
@@ skipping 46 matching lines @@
       .BinaryOperation(Token::Value::SUB, reg)
       .BinaryOperation(Token::Value::MUL, reg)
       .BinaryOperation(Token::Value::DIV, reg)
       .BinaryOperation(Token::Value::MOD, reg);
 
   // Emit bitwise operator invocations
   builder.BinaryOperation(Token::Value::BIT_OR, reg)
       .BinaryOperation(Token::Value::BIT_XOR, reg)
       .BinaryOperation(Token::Value::BIT_AND, reg);
 
+  // Emit bitwise AND with smi operand.
+  builder.LoadLiteral(Smi::FromInt(8))
+      .BinaryOperation(Token::Value::BIT_AND, reg);
+
+  // Emit bitwise OR with smi operand.
+  builder.LoadLiteral(Smi::FromInt(8))
+      .BinaryOperation(Token::Value::BIT_OR, reg);
+
   // Emit shift operator invocations
   builder.BinaryOperation(Token::Value::SHL, reg)
       .BinaryOperation(Token::Value::SAR, reg)
       .BinaryOperation(Token::Value::SHR, reg);
 
+  // Emit shift left with smi operand.
+  builder.LoadLiteral(Smi::FromInt(8)).BinaryOperation(Token::Value::SHL, reg);
+
+  // Emit shift right with smi operand.
+  builder.LoadLiteral(Smi::FromInt(8)).BinaryOperation(Token::Value::SAR, reg);
+
   // Emit count operatior invocations
   builder.CountOperation(Token::Value::ADD).CountOperation(Token::Value::SUB);
 
   // Emit unary operator invocations.
   builder
       .LogicalNot()  // ToBooleanLogicalNot
       .LogicalNot()  // non-ToBoolean LogicalNot
       .TypeOf();
 
   // Emit delete
@@ skipping 204 matching lines @@
   for (size_t i = 0; i < arraysize(end); i++) {
     builder.Bind(&end[i]);
   }
   builder.Return();
 
   // Generate BytecodeArray.
   Handle<BytecodeArray> the_array = builder.ToBytecodeArray();
   CHECK_EQ(the_array->frame_size(),
            builder.fixed_and_temporary_register_count() * kPointerSize);
 
+  the_array->Print();

[rmcilroy, 2016/07/04 12:35:32]

leftover debugging?

[oth, 2016/07/04 14:56:24]

Yep, done. :-)

+
   // Build scorecard of bytecodes encountered in the BytecodeArray.
   std::vector<int> scorecard(Bytecodes::ToByte(Bytecode::kLast) + 1);
 
   Bytecode final_bytecode = Bytecode::kLdaZero;
   int i = 0;
   while (i < the_array->length()) {
     uint8_t code = the_array->get(i);
     scorecard[code] += 1;
     final_bytecode = Bytecodes::FromByte(code);
     OperandScale operand_scale = OperandScale::kSingle;
@@ skipping 19 matching lines @@
     scorecard[Bytecodes::ToByte(Bytecode::kLdrKeyedProperty)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kLdrGlobal)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kLdrContextSlot)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kLdrUndefined)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kLogicalNot)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kJump)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrue)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalse)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kJumpIfTrueConstant)] = 1;
     scorecard[Bytecodes::ToByte(Bytecode::kJumpIfFalseConstant)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kAddSmi)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kSubSmi)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kBitwiseAndSmi)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kBitwiseOrSmi)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kShiftLeftSmi)] = 1;
+    scorecard[Bytecodes::ToByte(Bytecode::kShiftRightSmi)] = 1;
   }
 
   // Check return occurs at the end and only once in the BytecodeArray.
   CHECK_EQ(final_bytecode, Bytecode::kReturn);
   CHECK_EQ(scorecard[Bytecodes::ToByte(final_bytecode)], 1);
 
 #define CHECK_BYTECODE_PRESENT(Name, ...)                                \
   /* Check Bytecode is marked in scorecard, unless it's a debug break */ \
   if (!Bytecodes::IsDebugBreak(Bytecode::k##Name)) {                     \
     CHECK_GE(scorecard[Bytecodes::ToByte(Bytecode::k##Name)], 1);        \
@@ skipping 405 matching lines @@
     iterator.Advance();
   }
   CHECK_EQ(iterator.current_bytecode(), Bytecode::kReturn);
   iterator.Advance();
   CHECK(iterator.done());
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8