[interpreter] Introduce binary op bytecodes for Smi operand.

src/interpreter/bytecode-peephole-optimizer.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/bytecode-peephole-optimizer.h"
 
 #include "src/interpreter/constant-array-builder.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 
@@ skipping 108 matching lines @@
     // of back-to-back Ldar and Star bytecodes with the same operand.
     return true;
   } else if (current->bytecode() == Bytecode::kToName &&
              LastBytecodePutsNameInAccumulator()) {
     // If the previous bytecode ensured a name was in the accumulator,
     // the type coercion ToName() can be elided.
     return true;
   } else {
     // Additional candidates for eliding current:
     // (i) ToNumber if the last puts a number in the accumulator.
-    return false;
+    return current->bytecode() == Bytecode::kNop;

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

Can we do this in a separate CL please, so we can see the impact of this change
seperately from the SMI rhs

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

Done.

   }
 }
 
 bool BytecodePeepholeOptimizer::CanElideLastBasedOnSourcePosition(
     const BytecodeNode* const current) const {
   //
   // The rules for allowing the elision of the last bytecode based
   // on source position are:
   //
   //                     C U R R E N T
@@ skipping 41 matching lines @@
   //   Star R            ====/  Ldar R
   //
   // which loads a global value into both a register and the
   // accumulator. However, in the second form the Ldar can often be
   // peephole optimized away unlike the Star in the first form.
   //
   last->Transform(new_bytecode, current->operand(0));
   current->set_bytecode(Bytecode::kLdar, current->operand(0));
 }
 
+void TransformToBinaryOpWithSmiOnRhs(Bytecode new_bytecode,
+                                     BytecodeNode* const last,
+                                     BytecodeNode* const current) {
+  uint32_t smi_operand = last->operand(0);
+  current->set_bytecode(new_bytecode, smi_operand, current->operand(0));
+  if (last->source_info().is_valid()) {
+    current->source_info().Clone(last->source_info());
+  }
+}
+
 }  // namespace
 
 bool BytecodePeepholeOptimizer::TransformLastAndCurrentBytecodes(
     BytecodeNode* const current) {
   if (current->bytecode() == Bytecode::kStar &&
       !current->source_info().is_statement()) {
     // Note: If the Star is tagged with a statement position, we can't
     // perform this transform as the store to the register will
     // have the wrong ordering for stepping in the debugger.
     switch (last_.bytecode()) {
       case Bytecode::kLdaNamedProperty:
         TransformLdaStarToLdrLdar(Bytecode::kLdrNamedProperty, &last_, current);
         return true;
       case Bytecode::kLdaKeyedProperty:
         TransformLdaStarToLdrLdar(Bytecode::kLdrKeyedProperty, &last_, current);
         return true;
       case Bytecode::kLdaGlobal:
         TransformLdaStarToLdrLdar(Bytecode::kLdrGlobal, &last_, current);
         return true;
       case Bytecode::kLdaContextSlot:
         TransformLdaStarToLdrLdar(Bytecode::kLdrContextSlot, &last_, current);
         return true;
       case Bytecode::kLdaUndefined:
         TransformLdaStarToLdrLdar(Bytecode::kLdrUndefined, &last_, current);
         return true;
       default:
         break;
     }
+  } else if (last_.bytecode() == Bytecode::kLdaSmi &&
+             (!last_.source_info().is_valid() ||
+              !current->source_info().is_valid())) {
+    switch (current->bytecode()) {
+      case Bytecode::kAdd:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kAddSmi, &last_, current);
+        InvalidateLast();
+        return true;
+      case Bytecode::kSub:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kSubSmi, &last_, current);
+        InvalidateLast();
+        return true;
+      case Bytecode::kBitwiseOr:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kBitwiseOrSmi, &last_,
+                                        current);
+        InvalidateLast();
+        return true;
+      case Bytecode::kBitwiseAnd:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kBitwiseAndSmi, &last_,
+                                        current);
+        InvalidateLast();
+        return true;
+      case Bytecode::kShiftLeft:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kShiftLeftSmi, &last_,
+                                        current);
+        InvalidateLast();
+        return true;
+      case Bytecode::kShiftRight:
+        TransformToBinaryOpWithSmiOnRhs(Bytecode::kShiftRightSmi, &last_,
+                                        current);
+        InvalidateLast();
+        return true;
+      default:
+        break;
+    }
+  } else if (last_.bytecode() == Bytecode::kLdaZero &&

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

Can we not also do the LdaZero optimization for all cases above too?

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

Done. This was skipped due to low numbers of occurrences in Octane, but not a
significant tax.

+             current->bytecode() == Bytecode::kBitwiseOr &&
+             !current->source_info().is_valid()) {
+    current->set_bytecode(Bytecode::kBitwiseOrSmi, 0, current->operand(0));
+    current->source_info().Clone(last_.source_info());
+    InvalidateLast();
+    return true;
   }
+
   return false;
 }
 
 bool BytecodePeepholeOptimizer::RemoveToBooleanFromJump(
     BytecodeNode* const current) {
   bool can_remove = Bytecodes::IsJumpIfToBoolean(current->bytecode()) &&
                     Bytecodes::WritesBooleanToAccumulator(last_.bytecode());
   if (can_remove) {
     // Conditional jumps with boolean conditions are emiitted in
     // ToBoolean form by the bytecode array builder,
@@ skipping 42 matching lines @@
     // The current instruction clobbers the accumulator without reading it. The
     // load in the last instruction can be elided as it has no effect.
     return true;
   } else {
     return false;
   }
 }
 
 BytecodeNode* BytecodePeepholeOptimizer::Optimize(BytecodeNode* current) {
   TryToRemoveLastExpressionPosition(current);
-
   if (TransformCurrentBytecode(current) ||
       TransformLastAndCurrentBytecodes(current)) {
     return current;
   }
 
   if (CanElideCurrent(current)) {
     if (current->source_info().is_valid()) {
       // Preserve the source information by replacing the current bytecode
       // with a no op bytecode.
       current->set_bytecode(Bytecode::kNop);
@@ skipping 25 matching lines @@
       next_stage_->Write(&last_);
       InvalidateLast();
     }
   }
   return current;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8