Reland: [Interpreter] Move BinaryOp Smi transformation into BytecodeGenerator.""

This relands commit d3e9aade. The original CL was reverted speculatively but didn't cause the buildbot failure.

Original change's description:
> [Interpreter] Move BinaryOp Smi transformation into BytecodeGenerator.
> 
> Perform the transformation to <BinaryOp>Smi for Binary ops which take Smi
> literals in the BytecodeGenerator. This enables us to perform the
> transformation for literals on either side for commutative operations, and
> Avoids having to do the check on every bytecode in the peephole optimizer.
> 
> In the process, adds Smi bytecode variants for all binary operations, adding
>  - MulSmi
>  - DivSmi
>  - ModSmi
>  - BitwiseXorSmi
>  - ShiftRightLogical
> 
> BUG=v8:6194
> 
> Change-Id: If1484252f5385c16957004b9cac8bfbb1f209219
> Reviewed-on: https://chromium-review.googlesource.com/466246
> Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
> Reviewed-by: Yang Guo <yangguo@chromium.org>
> Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
> Reviewed-by: Igor Sheludko <ishell@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#44477}

TBR=rmcilroy@chromium.org,machenbach@chromium.org,yangguo@chromium.org,mstarzinger@chromium.org,mythria@chromium.org,v8-reviews@googlegroups.com,ishell@chromium.org
# Not skipping CQ checks because original CL landed > 1 day ago.
BUG=v8:6194

Change-Id: I2ccaefa1ce58d3885f5c2648755985c06f25c1d8
Reviewed-on: https://chromium-review.googlesource.com/472746Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#44511}

src/ast/ast.cc

@@ -884,6 +884,30 @@ void BinaryOperation::AssignFeedbackSlots(FeedbackVectorSpec* spec,
   }
 }
 
+static bool IsCommutativeOperationWithSmiLiteral(Token::Value op) {
+  // Add is not commutative due to potential for string addition.
+  return op == Token::MUL || op == Token::BIT_AND || op == Token::BIT_OR ||
+         op == Token::BIT_XOR;
+}
+
+// Check for the pattern: x + 1.
+static bool MatchSmiLiteralOperation(Expression* left, Expression* right,
+                                     Expression** expr, Smi** literal) {
+  if (right->IsSmiLiteral()) {
+    *expr = left;
+    *literal = right->AsLiteral()->AsSmiLiteral();
+    return true;
+  }
+  return false;
+}
+
+bool BinaryOperation::IsSmiLiteralOperation(Expression** subexpr,
+                                            Smi** literal) {
+  return MatchSmiLiteralOperation(left_, right_, subexpr, literal) ||
+         (IsCommutativeOperationWithSmiLiteral(op()) &&
+          MatchSmiLiteralOperation(right_, left_, subexpr, literal));
+}
+
 static bool IsTypeof(Expression* expr) {
   UnaryOperation* maybe_unary = expr->AsUnaryOperation();
   return maybe_unary != NULL && maybe_unary->op() == Token::TYPEOF;

src/ast/ast.h

@@ -1201,6 +1201,11 @@ class Literal final : public Expression {
     return value_->AsString();
   }
 
+  Smi* AsSmiLiteral() {
+    DCHECK(IsSmiLiteral());
+    return raw_value()->AsSmi();
+  }
+
   bool ToBooleanIsTrue() const { return raw_value()->BooleanValue(); }
   bool ToBooleanIsFalse() const { return !raw_value()->BooleanValue(); }
 
@@ -2134,6 +2139,11 @@ class BinaryOperation final : public Expression {
   TypeFeedbackId BinaryOperationFeedbackId() const {
     return TypeFeedbackId(local_id(1));
   }
+
+  // Returns true if one side is a Smi literal, returning the other side's
+  // sub-expression in |subexpr| and the literal Smi in |literal|.
+  bool IsSmiLiteralOperation(Expression** subexpr, Smi** literal);
+
   Maybe<int> fixed_right_arg() const {
     return has_fixed_right_arg_ ? Just(fixed_right_arg_value_) : Nothing<int>();
   }

src/builtins/builtins-definitions.h

@@ -624,6 +624,9 @@ namespace internal {
   TFC(StrictEqual, Compare, 1)                                                 \
   TFC(AddWithFeedback, BinaryOpWithVector, 1)                                  \
   TFC(SubtractWithFeedback, BinaryOpWithVector, 1)                             \
+  TFC(MultiplyWithFeedback, BinaryOpWithVector, 1)                             \
+  TFC(DivideWithFeedback, BinaryOpWithVector, 1)                               \
+  TFC(ModulusWithFeedback, BinaryOpWithVector, 1)                              \
                                                                                \
   /* Object */                                                                 \
   CPP(ObjectAssign)                                                            \

src/builtins/builtins-number-gen.cc

@@ -1415,5 +1415,38 @@ TF_BUILTIN(SubtractWithFeedback, BinaryOpAssembler) {
                                        ChangeUint32ToWord(slot), vector));
 }
 
+TF_BUILTIN(MultiplyWithFeedback, BinaryOpAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
+  Node* slot = Parameter(Descriptor::kSlot);
+  Node* vector = Parameter(Descriptor::kVector);
+
+  Return(Generate_MultiplyWithFeedback(context, left, right,
+                                       ChangeUint32ToWord(slot), vector));
+}
+
+TF_BUILTIN(DivideWithFeedback, BinaryOpAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
+  Node* slot = Parameter(Descriptor::kSlot);
+  Node* vector = Parameter(Descriptor::kVector);
+
+  Return(Generate_DivideWithFeedback(context, left, right,
+                                     ChangeUint32ToWord(slot), vector));
+}
+
+TF_BUILTIN(ModulusWithFeedback, BinaryOpAssembler) {
+  Node* context = Parameter(Descriptor::kContext);
+  Node* left = Parameter(Descriptor::kLeft);
+  Node* right = Parameter(Descriptor::kRight);
+  Node* slot = Parameter(Descriptor::kSlot);
+  Node* vector = Parameter(Descriptor::kVector);
+
+  Return(Generate_ModulusWithFeedback(context, left, right,
+                                      ChangeUint32ToWord(slot), vector));
+}
+
 }  // namespace internal
 }  // namespace v8

src/code-stub-assembler.cc

@@ -581,6 +581,53 @@ Node* CodeStubAssembler::SmiMul(Node* a, Node* b) {
   return var_result.value();
 }
 
+Node* CodeStubAssembler::TrySmiDiv(Node* dividend, Node* divisor,
+                                   Label* bailout) {
+  // Both {a} and {b} are Smis. Bailout to floating point division if {divisor}
+  // is zero.
+  GotoIf(WordEqual(divisor, SmiConstant(0)), bailout);
+
+  // Do floating point division if {dividend} is zero and {divisor} is
+  // negative.
+  Label dividend_is_zero(this), dividend_is_not_zero(this);
+  Branch(WordEqual(dividend, SmiConstant(0)), &dividend_is_zero,
+         &dividend_is_not_zero);
+
+  Bind(&dividend_is_zero);
+  {
+    GotoIf(SmiLessThan(divisor, SmiConstant(0)), bailout);
+    Goto(&dividend_is_not_zero);
+  }
+  Bind(&dividend_is_not_zero);
+
+  Node* untagged_divisor = SmiToWord32(divisor);
+  Node* untagged_dividend = SmiToWord32(dividend);
+
+  // Do floating point division if {dividend} is kMinInt (or kMinInt - 1
+  // if the Smi size is 31) and {divisor} is -1.
+  Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);
+  Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),
+         &divisor_is_minus_one, &divisor_is_not_minus_one);
+
+  Bind(&divisor_is_minus_one);
+  {
+    GotoIf(Word32Equal(
+               untagged_dividend,
+               Int32Constant(kSmiValueSize == 32 ? kMinInt : (kMinInt >> 1))),
+           bailout);
+    Goto(&divisor_is_not_minus_one);
+  }
+  Bind(&divisor_is_not_minus_one);
+
+  Node* untagged_result = Int32Div(untagged_dividend, untagged_divisor);
+  Node* truncated = Int32Mul(untagged_result, untagged_divisor);
+
+  // Do floating point division if the remainder is not 0.
+  GotoIf(Word32NotEqual(untagged_dividend, truncated), bailout);
+
+  return SmiFromWord32(untagged_result);
+}
+
 Node* CodeStubAssembler::TruncateWordToWord32(Node* value) {
   if (Is64()) {
     return TruncateInt64ToInt32(value);

src/code-stub-assembler.h

@@ -237,6 +237,9 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
   Node* SmiMod(Node* a, Node* b);
   // Computes a * b for Smi inputs a and b; result is not necessarily a Smi.
   Node* SmiMul(Node* a, Node* b);
+  // Tries to computes dividend / divisor for Smi inputs; branching to bailout
+  // if the division needs to be performed as a floating point operation.
+  Node* TrySmiDiv(Node* dividend, Node* divisor, Label* bailout);
 
   // Smi | HeapNumber operations.
   Node* NumberInc(Node* value);

src/compiler/bytecode-graph-builder.cc

@@ -1745,8 +1745,7 @@ void BytecodeGraphBuilder::VisitShiftRightLogical() {
 
 void BytecodeGraphBuilder::BuildBinaryOpWithImmediate(const Operator* op) {
   PrepareEagerCheckpoint();
-  Node* left =
-      environment()->LookupRegister(bytecode_iterator().GetRegisterOperand(1));
+  Node* left = environment()->LookupAccumulator();
   Node* right = jsgraph()->Constant(bytecode_iterator().GetImmediateOperand(0));
 
   Node* node = nullptr;
@@ -1770,10 +1769,26 @@ void BytecodeGraphBuilder::VisitSubSmi() {
   BuildBinaryOpWithImmediate(javascript()->Subtract());
 }
 
+void BytecodeGraphBuilder::VisitMulSmi() {
+  BuildBinaryOpWithImmediate(javascript()->Multiply());
+}
+
+void BytecodeGraphBuilder::VisitDivSmi() {
+  BuildBinaryOpWithImmediate(javascript()->Divide());
+}
+
+void BytecodeGraphBuilder::VisitModSmi() {
+  BuildBinaryOpWithImmediate(javascript()->Modulus());
+}
+
 void BytecodeGraphBuilder::VisitBitwiseOrSmi() {
   BuildBinaryOpWithImmediate(javascript()->BitwiseOr());
 }
 
+void BytecodeGraphBuilder::VisitBitwiseXorSmi() {
+  BuildBinaryOpWithImmediate(javascript()->BitwiseXor());
+}
+
 void BytecodeGraphBuilder::VisitBitwiseAndSmi() {
   BuildBinaryOpWithImmediate(javascript()->BitwiseAnd());
 }
@@ -1786,6 +1801,10 @@ void BytecodeGraphBuilder::VisitShiftRightSmi() {
   BuildBinaryOpWithImmediate(javascript()->ShiftRight());
 }
 
+void BytecodeGraphBuilder::VisitShiftRightLogicalSmi() {
+  BuildBinaryOpWithImmediate(javascript()->ShiftRightLogical());
+}
+
 void BytecodeGraphBuilder::VisitInc() {
   PrepareEagerCheckpoint();
   // Note: Use subtract -1 here instead of add 1 to ensure we always convert to

src/compiler/bytecode-graph-builder.h

@@ -362,7 +362,7 @@ class BytecodeGraphBuilder {
 
   static int const kBinaryOperationHintIndex = 1;
   static int const kCountOperationHintIndex = 0;
-  static int const kBinaryOperationSmiHintIndex = 2;
+  static int const kBinaryOperationSmiHintIndex = 1;
 
   DISALLOW_COPY_AND_ASSIGN(BytecodeGraphBuilder);
 };

src/debug/debug-evaluate.cc

@@ -353,18 +353,23 @@ bool BytecodeHasNoSideEffect(interpreter::Bytecode bytecode) {
     case Bytecode::kSub:
     case Bytecode::kSubSmi:
     case Bytecode::kMul:
+    case Bytecode::kMulSmi:
     case Bytecode::kDiv:
+    case Bytecode::kDivSmi:
     case Bytecode::kMod:
+    case Bytecode::kModSmi:
     case Bytecode::kBitwiseAnd:
     case Bytecode::kBitwiseAndSmi:
     case Bytecode::kBitwiseOr:
     case Bytecode::kBitwiseOrSmi:
     case Bytecode::kBitwiseXor:
+    case Bytecode::kBitwiseXorSmi:
     case Bytecode::kShiftLeft:
     case Bytecode::kShiftLeftSmi:
     case Bytecode::kShiftRight:
     case Bytecode::kShiftRightSmi:
     case Bytecode::kShiftRightLogical:
+    case Bytecode::kShiftRightLogicalSmi:
     case Bytecode::kInc:
     case Bytecode::kDec:
     case Bytecode::kLogicalNot:

src/ic/binary-op-assembler.cc

@@ -546,48 +546,10 @@ Node* BinaryOpAssembler::Generate_DivideWithFeedback(Node* context,
     {
       Label bailout(this);
 
-      // Do floating point division if {divisor} is zero.
-      GotoIf(WordEqual(divisor, SmiConstant(0)), &bailout);
-
-      // Do floating point division {dividend} is zero and {divisor} is
-      // negative.
-      Label dividend_is_zero(this), dividend_is_not_zero(this);
-      Branch(WordEqual(dividend, SmiConstant(0)), &dividend_is_zero,
-             &dividend_is_not_zero);
-
-      BIND(&dividend_is_zero);
-      {
-        GotoIf(SmiLessThan(divisor, SmiConstant(0)), &bailout);
-        Goto(&dividend_is_not_zero);
-      }
-      BIND(&dividend_is_not_zero);
-
-      Node* untagged_divisor = SmiToWord32(divisor);
-      Node* untagged_dividend = SmiToWord32(dividend);
-
-      // Do floating point division if {dividend} is kMinInt (or kMinInt - 1
-      // if the Smi size is 31) and {divisor} is -1.
-      Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);
-      Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),
-             &divisor_is_minus_one, &divisor_is_not_minus_one);
-
-      BIND(&divisor_is_minus_one);
-      {
-        GotoIf(Word32Equal(untagged_dividend,
-                           Int32Constant(kSmiValueSize == 32 ? kMinInt
-                                                             : (kMinInt >> 1))),
-               &bailout);
-        Goto(&divisor_is_not_minus_one);
-      }
-      BIND(&divisor_is_not_minus_one);
-
-      Node* untagged_result = Int32Div(untagged_dividend, untagged_divisor);
-      Node* truncated = Int32Mul(untagged_result, untagged_divisor);
-      // Do floating point division if the remainder is not 0.
-      GotoIf(Word32NotEqual(untagged_dividend, truncated), &bailout);
+      // Try to perform Smi division if possible.
+      var_result.Bind(TrySmiDiv(dividend, divisor, &bailout));
       var_type_feedback.Bind(
           SmiConstant(BinaryOperationFeedback::kSignedSmall));
-      var_result.Bind(SmiFromWord32(untagged_result));
       Goto(&end);
 
       // Bailout: convert {dividend} and {divisor} to double and do double

src/interpreter/bytecode-array-builder.cc

@@ -389,6 +389,48 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperation(Token::Value op,
   return *this;
 }
 
+BytecodeArrayBuilder& BytecodeArrayBuilder::BinaryOperationSmiLiteral(
+    Token::Value op, Smi* literal, int feedback_slot) {
+  switch (op) {
+    case Token::Value::ADD:
+      OutputAddSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::SUB:
+      OutputSubSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::MUL:
+      OutputMulSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::DIV:
+      OutputDivSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::MOD:
+      OutputModSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::BIT_OR:
+      OutputBitwiseOrSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::BIT_XOR:
+      OutputBitwiseXorSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::BIT_AND:
+      OutputBitwiseAndSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::SHL:
+      OutputShiftLeftSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::SAR:
+      OutputShiftRightSmi(literal->value(), feedback_slot);
+      break;
+    case Token::Value::SHR:
+      OutputShiftRightLogicalSmi(literal->value(), feedback_slot);
+      break;
+    default:
+      UNREACHABLE();
+  }
+  return *this;
+}
+
 BytecodeArrayBuilder& BytecodeArrayBuilder::CountOperation(Token::Value op,
                                                            int feedback_slot) {
   if (op == Token::Value::ADD) {

src/interpreter/bytecode-array-builder.h

@@ -292,6 +292,9 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final
   // Type feedback will be recorded in the |feedback_slot|
   BytecodeArrayBuilder& BinaryOperation(Token::Value binop, Register reg,
                                         int feedback_slot);
+  BytecodeArrayBuilder& BinaryOperationSmiLiteral(Token::Value binop,
+                                                  Smi* literal,
+                                                  int feedback_slot);
 
   // Count Operators (value stored in accumulator).
   // Type feedback will be recorded in the |feedback_slot|

src/interpreter/bytecode-generator.cc

@@ -2299,50 +2299,48 @@ void BytecodeGenerator::VisitAssignment(Assignment* expr) {
   // Evaluate the value and potentially handle compound assignments by loading
   // the left-hand side value and performing a binary operation.
   if (expr->is_compound()) {
-    Register old_value = register_allocator()->NewRegister();
     switch (assign_type) {
       case VARIABLE: {
         VariableProxy* proxy = expr->target()->AsVariableProxy();
         BuildVariableLoad(proxy->var(), proxy->VariableFeedbackSlot(),
                           proxy->hole_check_mode());
-        builder()->StoreAccumulatorInRegister(old_value);
         break;
       }
       case NAMED_PROPERTY: {
         FeedbackSlot slot = property->PropertyFeedbackSlot();
-        builder()
-            ->LoadNamedProperty(object, name, feedback_index(slot))
-            .StoreAccumulatorInRegister(old_value);
+        builder()->LoadNamedProperty(object, name, feedback_index(slot));
         break;
       }
       case KEYED_PROPERTY: {
         // Key is already in accumulator at this point due to evaluating the
         // LHS above.
         FeedbackSlot slot = property->PropertyFeedbackSlot();
-        builder()
-            ->LoadKeyedProperty(object, feedback_index(slot))
-            .StoreAccumulatorInRegister(old_value);
+        builder()->LoadKeyedProperty(object, feedback_index(slot));
         break;
       }
       case NAMED_SUPER_PROPERTY: {
-        builder()
-            ->CallRuntime(Runtime::kLoadFromSuper,
-                          super_property_args.Truncate(3))
-            .StoreAccumulatorInRegister(old_value);
+        builder()->CallRuntime(Runtime::kLoadFromSuper,
+                               super_property_args.Truncate(3));
         break;
       }
       case KEYED_SUPER_PROPERTY: {
-        builder()
-            ->CallRuntime(Runtime::kLoadKeyedFromSuper,
-                          super_property_args.Truncate(3))
-            .StoreAccumulatorInRegister(old_value);
+        builder()->CallRuntime(Runtime::kLoadKeyedFromSuper,
+                               super_property_args.Truncate(3));
         break;
       }
     }
-    VisitForAccumulatorValue(expr->value());
     FeedbackSlot slot = expr->binary_operation()->BinaryOperationFeedbackSlot();
-    builder()->BinaryOperation(expr->binary_op(), old_value,
-                               feedback_index(slot));
+    if (expr->value()->IsSmiLiteral()) {
+      builder()->BinaryOperationSmiLiteral(
+          expr->binary_op(), expr->value()->AsLiteral()->AsSmiLiteral(),
+          feedback_index(slot));
+    } else {
+      Register old_value = register_allocator()->NewRegister();
+      builder()->StoreAccumulatorInRegister(old_value);
+      VisitForAccumulatorValue(expr->value());
+      builder()->BinaryOperation(expr->binary_op(), old_value,
+                                 feedback_index(slot));
+    }
   } else {
     VisitForAccumulatorValue(expr->value());
   }
@@ -3109,11 +3107,20 @@ void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
   // TODO(rmcilroy): Special case "x * 1.0" and "x * -1" which are generated for
   // +x and -x by the parser.
-  Register lhs = VisitForRegisterValue(expr->left());
-  VisitForAccumulatorValue(expr->right());
   FeedbackSlot slot = expr->BinaryOperationFeedbackSlot();
-  builder()->SetExpressionPosition(expr);
-  builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
+  Expression* subexpr;
+  Smi* literal;
+  if (expr->IsSmiLiteralOperation(&subexpr, &literal)) {
+    VisitForAccumulatorValue(subexpr);
+    builder()->SetExpressionPosition(expr);
+    builder()->BinaryOperationSmiLiteral(expr->op(), literal,
+                                         feedback_index(slot));
+  } else {
+    Register lhs = VisitForRegisterValue(expr->left());
+    VisitForAccumulatorValue(expr->right());
+    builder()->SetExpressionPosition(expr);
+    builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
+  }
 }
 
 void BytecodeGenerator::VisitSpread(Spread* expr) { Visit(expr->expression()); }

src/interpreter/bytecode-peephole-optimizer.cc

@@ -117,30 +117,6 @@ bool BytecodePeepholeOptimizer::CanElideLastBasedOnSourcePosition(
 
 namespace {
 
-BytecodeNode TransformLdaSmiBinaryOpToBinaryOpWithSmi(
-    Bytecode new_bytecode, BytecodeNode* const last,
-    BytecodeNode* const current) {
-  DCHECK_EQ(last->bytecode(), Bytecode::kLdaSmi);
-  BytecodeNode node(new_bytecode, last->operand(0), current->operand(0),
-                    current->operand(1), current->source_info());
-  if (last->source_info().is_valid()) {
-    node.set_source_info(last->source_info());
-  }
-  return node;
-}
-
-BytecodeNode TransformLdaZeroBinaryOpToBinaryOpWithZero(
-    Bytecode new_bytecode, BytecodeNode* const last,
-    BytecodeNode* const current) {
-  DCHECK_EQ(last->bytecode(), Bytecode::kLdaZero);
-  BytecodeNode node(new_bytecode, 0, current->operand(0), current->operand(1),
-                    current->source_info());
-  if (last->source_info().is_valid()) {
-    node.set_source_info(last->source_info());
-  }
-  return node;
-}
-
 }  // namespace
 
 void BytecodePeepholeOptimizer::DefaultAction(
@@ -224,36 +200,6 @@ void BytecodePeepholeOptimizer::ChangeBytecodeAction(
   DefaultAction(node);
 }
 
-void BytecodePeepholeOptimizer::TransformLdaSmiBinaryOpToBinaryOpWithSmiAction(
-    BytecodeNode* const node, const PeepholeActionAndData* action_data) {
-  DCHECK(LastIsValid());
-  DCHECK(!Bytecodes::IsJump(node->bytecode()));
-
-  if (!node->source_info().is_valid() || !last()->source_info().is_valid()) {
-    // Fused last and current into current.
-    BytecodeNode new_node(TransformLdaSmiBinaryOpToBinaryOpWithSmi(
-        action_data->bytecode, last(), node));
-    SetLast(&new_node);
-  } else {
-    DefaultAction(node);
-  }
-}
-
-void BytecodePeepholeOptimizer::
-    TransformLdaZeroBinaryOpToBinaryOpWithZeroAction(
-        BytecodeNode* const node, const PeepholeActionAndData* action_data) {
-  DCHECK(LastIsValid());
-  DCHECK(!Bytecodes::IsJump(node->bytecode()));
-  if (!node->source_info().is_valid() || !last()->source_info().is_valid()) {
-    // Fused last and current into current.
-    BytecodeNode new_node(TransformLdaZeroBinaryOpToBinaryOpWithZero(
-        action_data->bytecode, last(), node));
-    SetLast(&new_node);
-  } else {
-    DefaultAction(node);
-  }
-}
-
 void BytecodePeepholeOptimizer::DefaultJumpAction(
     BytecodeNode* const node, const PeepholeActionAndData* action_data) {
   DCHECK(LastIsValid());

src/interpreter/bytecode-peephole-table.h

@@ -11,16 +11,14 @@ namespace v8 {
 namespace internal {
 namespace interpreter {
 
-#define PEEPHOLE_NON_JUMP_ACTION_LIST(V)            \
-  V(DefaultAction)                                  \
-  V(UpdateLastAction)                               \
-  V(UpdateLastIfSourceInfoPresentAction)            \
-  V(ElideCurrentAction)                             \
-  V(ElideCurrentIfOperand0MatchesAction)            \
-  V(ElideLastAction)                                \
-  V(ChangeBytecodeAction)                           \
-  V(TransformLdaSmiBinaryOpToBinaryOpWithSmiAction) \
-  V(TransformLdaZeroBinaryOpToBinaryOpWithZeroAction)
+#define PEEPHOLE_NON_JUMP_ACTION_LIST(V) \
+  V(DefaultAction)                       \
+  V(UpdateLastAction)                    \
+  V(UpdateLastIfSourceInfoPresentAction) \
+  V(ElideCurrentAction)                  \
+  V(ElideCurrentIfOperand0MatchesAction) \
+  V(ElideLastAction)                     \
+  V(ChangeBytecodeAction)
 
 #define PEEPHOLE_JUMP_ACTION_LIST(V) \
   V(DefaultJumpAction)               \

src/interpreter/bytecodes.h

@@ -127,18 +127,23 @@ namespace interpreter {
     OperandType::kIdx)                                                         \
                                                                                \
   /* Binary operators with immediate operands */                               \
-  V(AddSmi, AccumulatorUse::kWrite, OperandType::kImm, OperandType::kReg,      \
+  V(AddSmi, AccumulatorUse::kReadWrite, OperandType::kImm, OperandType::kIdx)  \
+  V(SubSmi, AccumulatorUse::kReadWrite, OperandType::kImm, OperandType::kIdx)  \
+  V(MulSmi, AccumulatorUse::kReadWrite, OperandType::kImm, OperandType::kIdx)  \
+  V(DivSmi, AccumulatorUse::kReadWrite, OperandType::kImm, OperandType::kIdx)  \
+  V(ModSmi, AccumulatorUse::kReadWrite, OperandType::kImm, OperandType::kIdx)  \
+  V(BitwiseOrSmi, AccumulatorUse::kReadWrite, OperandType::kImm,               \
     OperandType::kIdx)                                                         \
-  V(SubSmi, AccumulatorUse::kWrite, OperandType::kImm, OperandType::kReg,      \
+  V(BitwiseXorSmi, AccumulatorUse::kReadWrite, OperandType::kImm,              \
+    OperandType::kIdx)                                                         \
+  V(BitwiseAndSmi, AccumulatorUse::kReadWrite, OperandType::kImm,              \
+    OperandType::kIdx)                                                         \
+  V(ShiftLeftSmi, AccumulatorUse::kReadWrite, OperandType::kImm,               \
+    OperandType::kIdx)                                                         \
+  V(ShiftRightSmi, AccumulatorUse::kReadWrite, OperandType::kImm,              \
+    OperandType::kIdx)                                                         \
+  V(ShiftRightLogicalSmi, AccumulatorUse::kReadWrite, OperandType::kImm,       \
     OperandType::kIdx)                                                         \
-  V(BitwiseOrSmi, AccumulatorUse::kWrite, OperandType::kImm,                   \
-    OperandType::kReg, OperandType::kIdx)                                      \
-  V(BitwiseAndSmi, AccumulatorUse::kWrite, OperandType::kImm,                  \
-    OperandType::kReg, OperandType::kIdx)                                      \
-  V(ShiftLeftSmi, AccumulatorUse::kWrite, OperandType::kImm,                   \
-    OperandType::kReg, OperandType::kIdx)                                      \
-  V(ShiftRightSmi, AccumulatorUse::kWrite, OperandType::kImm,                  \
-    OperandType::kReg, OperandType::kIdx)                                      \
                                                                                \
   /* Unary Operators */                                                        \
   V(Inc, AccumulatorUse::kReadWrite, OperandType::kIdx)                        \

src/interpreter/mkpeephole.cc

@@ -106,66 +106,6 @@ PeepholeActionAndData PeepholeActionTableWriter::LookupActionAndData(
   // TODO(rmcilroy): Add elide for consecutive mov to and from the same
   // register.
 
-  // Fuse LdaSmi followed by binary op to produce binary op with a
-  // immediate integer argument. This savaes on dispatches and size.
-  if (last == Bytecode::kLdaSmi) {
-    switch (current) {
-      case Bytecode::kAdd:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kAddSmi};
-      case Bytecode::kSub:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kSubSmi};
-      case Bytecode::kBitwiseAnd:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kBitwiseAndSmi};
-      case Bytecode::kBitwiseOr:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kBitwiseOrSmi};
-      case Bytecode::kShiftLeft:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kShiftLeftSmi};
-      case Bytecode::kShiftRight:
-        return {PeepholeAction::kTransformLdaSmiBinaryOpToBinaryOpWithSmiAction,
-                Bytecode::kShiftRightSmi};
-      default:
-        break;
-    }
-  }
-
-  // Fuse LdaZero followed by binary op to produce binary op with a
-  // zero immediate argument. This saves dispatches, but not size.
-  if (last == Bytecode::kLdaZero) {
-    switch (current) {
-      case Bytecode::kAdd:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kAddSmi};
-      case Bytecode::kSub:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kSubSmi};
-      case Bytecode::kBitwiseAnd:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kBitwiseAndSmi};
-      case Bytecode::kBitwiseOr:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kBitwiseOrSmi};
-      case Bytecode::kShiftLeft:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kShiftLeftSmi};
-      case Bytecode::kShiftRight:
-        return {
-            PeepholeAction::kTransformLdaZeroBinaryOpToBinaryOpWithZeroAction,
-            Bytecode::kShiftRightSmi};
-      default:
-        break;
-    }
-  }
-
   // If there is no last bytecode to optimize against, store the incoming
   // bytecode or for jumps emit incoming bytecode immediately.
   if (last == Bytecode::kIllegal) {

test/cctest/interpreter/bytecode_expectations/ArrayLiterals.golden

@@ -29,7 +29,7 @@ snippet: "
 "
 frame size: 3
 parameter count: 1
-bytecode array length: 35
+bytecode array length: 36
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
@@ -42,7 +42,8 @@ bytecodes: [
   /*   54 E> */ B(StaKeyedPropertySloppy), R(2), R(1), U8(4),
                 B(LdaSmi), I8(1),
                 B(Star), R(1),
-  /*   59 E> */ B(AddSmi), I8(1), R(0), U8(2),
+                B(Ldar), R(0),
+  /*   59 E> */ B(AddSmi), I8(1), U8(2),
                 B(StaKeyedPropertySloppy), R(2), R(1), U8(4),
                 B(Ldar), R(2),
   /*   66 S> */ B(Return),
@@ -77,7 +78,7 @@ snippet: "
 "
 frame size: 5
 parameter count: 1
-bytecode array length: 65
+bytecode array length: 66
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
@@ -100,7 +101,8 @@ bytecodes: [
                 B(Star), R(4),
                 B(LdaZero),
                 B(Star), R(3),
-  /*   68 E> */ B(AddSmi), I8(2), R(0), U8(5),
+                B(Ldar), R(0),
+  /*   68 E> */ B(AddSmi), I8(2), U8(5),
                 B(StaKeyedPropertySloppy), R(4), R(3), U8(7),
                 B(Ldar), R(4),
                 B(StaKeyedPropertySloppy), R(2), R(1), U8(10),

test/cctest/interpreter/bytecode_expectations/AssignmentsInBinaryExpression.golden

@@ -195,7 +195,7 @@ snippet: "
 "
 frame size: 4
 parameter count: 1
-bytecode array length: 72
+bytecode array length: 73
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(10),
@@ -207,7 +207,8 @@ bytecodes: [
                 B(Star), R(0),
   /*   63 E> */ B(Add), R(2), U8(2),
                 B(Star), R(2),
-  /*   78 E> */ B(AddSmi), I8(1), R(0), U8(3),
+                B(Ldar), R(0),
+  /*   78 E> */ B(AddSmi), I8(1), U8(3),
                 B(Star), R(3),
                 B(LdaSmi), I8(2),
                 B(Star), R(1),

test/cctest/interpreter/bytecode_expectations/BasicLoops.golden

@@ -74,11 +74,11 @@ bytecodes: [
   /*   65 E> */ B(TestLessThan), R(0), U8(2),
                 B(JumpIfFalse), U8(38),
   /*   56 E> */ B(StackCheck),
-  /*   75 S> */ B(LdaSmi), I8(12),
-  /*   81 E> */ B(Mul), R(1), U8(3),
+  /*   75 S> */ B(Ldar), R(1),
+  /*   81 E> */ B(MulSmi), I8(12), U8(3),
                 B(Star), R(1),
-  /*   89 S> */ B(LdaSmi), I8(1),
-  /*   95 E> */ B(Add), R(0), U8(4),
+  /*   89 S> */ B(Ldar), R(0),
+  /*   95 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
   /*  102 S> */ B(LdaSmi), I8(3),
   /*  108 E> */ B(TestEqual), R(0), U8(5),
@@ -138,8 +138,8 @@ bytecodes: [
   /*  158 E> */ B(TestEqual), R(0), U8(6),
                 B(JumpIfFalse), U8(4),
   /*  164 S> */ B(Jump), U8(12),
-  /*  173 S> */ B(LdaSmi), I8(1),
-  /*  179 E> */ B(Add), R(0), U8(7),
+  /*  173 S> */ B(Ldar), R(0),
+  /*  179 E> */ B(AddSmi), I8(1), U8(7),
                 B(Star), R(0),
                 B(JumpLoop), U8(52), I8(0),
   /*  186 S> */ B(Ldar), R(0),
@@ -179,12 +179,12 @@ bytecodes: [
   /*   88 E> */ B(TestEqual), R(0), U8(3),
                 B(JumpIfFalse), U8(4),
   /*   94 S> */ B(Jump), U8(12),
-  /*  105 S> */ B(LdaSmi), I8(1),
-  /*  111 E> */ B(Add), R(0), U8(4),
+  /*  105 S> */ B(Ldar), R(0),
+  /*  111 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
                 B(JumpLoop), U8(24), I8(1),
-  /*  122 S> */ B(LdaSmi), I8(1),
-  /*  128 E> */ B(Add), R(0), U8(5),
+  /*  122 S> */ B(Ldar), R(0),
+  /*  128 E> */ B(AddSmi), I8(1), U8(5),
                 B(Star), R(0),
   /*  135 S> */ B(Jump), U8(2),
   /*  144 S> */ B(Ldar), R(0),
@@ -217,11 +217,11 @@ bytecodes: [
   /*   64 S> */ B(Ldar), R(0),
                 B(JumpIfToBooleanFalse), U8(20),
   /*   57 E> */ B(StackCheck),
-  /*   71 S> */ B(LdaSmi), I8(12),
-  /*   77 E> */ B(Mul), R(1), U8(2),
+  /*   71 S> */ B(Ldar), R(1),
+  /*   77 E> */ B(MulSmi), I8(12), U8(2),
                 B(Star), R(1),
-  /*   85 S> */ B(LdaSmi), I8(1),
-  /*   91 E> */ B(Sub), R(0), U8(3),
+  /*   85 S> */ B(Ldar), R(0),
+  /*   91 E> */ B(SubSmi), I8(1), U8(3),
                 B(Star), R(0),
                 B(JumpLoop), U8(19), I8(0),
   /*   98 S> */ B(Ldar), R(1),
@@ -253,8 +253,8 @@ bytecodes: [
   /*   53 S> */ B(LdaSmi), I8(1),
                 B(Star), R(1),
   /*   56 E> */ B(StackCheck),
-  /*   63 S> */ B(LdaSmi), I8(10),
-  /*   69 E> */ B(Mul), R(1), U8(2),
+  /*   63 S> */ B(Ldar), R(1),
+  /*   69 E> */ B(MulSmi), I8(10), U8(2),
                 B(Star), R(1),
   /*   77 S> */ B(LdaSmi), I8(5),
   /*   83 E> */ B(TestEqual), R(0), U8(3),
@@ -264,8 +264,8 @@ bytecodes: [
   /*  104 E> */ B(TestEqual), R(0), U8(4),
                 B(JumpIfFalse), U8(4),
   /*  110 S> */ B(Jump), U8(9),
-  /*  122 S> */ B(LdaSmi), I8(1),
-  /*  128 E> */ B(Add), R(0), U8(5),
+  /*  122 S> */ B(Ldar), R(0),
+  /*  128 E> */ B(AddSmi), I8(1), U8(5),
                 B(Star), R(0),
   /*  144 S> */ B(LdaSmi), I8(10),
   /*  144 E> */ B(TestLessThan), R(0), U8(6),
@@ -299,11 +299,11 @@ bytecodes: [
   /*   54 S> */ B(LdaSmi), I8(1),
                 B(Star), R(1),
   /*   57 E> */ B(StackCheck),
-  /*   64 S> */ B(LdaSmi), I8(12),
-  /*   70 E> */ B(Mul), R(1), U8(2),
+  /*   64 S> */ B(Ldar), R(1),
+  /*   70 E> */ B(MulSmi), I8(12), U8(2),
                 B(Star), R(1),
-  /*   78 S> */ B(LdaSmi), I8(1),
-  /*   84 E> */ B(Sub), R(0), U8(3),
+  /*   78 S> */ B(Ldar), R(0),
+  /*   84 E> */ B(SubSmi), I8(1), U8(3),
                 B(Star), R(0),
   /*   98 S> */ B(JumpIfToBooleanFalse), U8(5),
                 B(JumpLoop), U8(17), I8(0),
@@ -328,7 +328,7 @@ snippet: "
 "
 frame size: 2
 parameter count: 1
-bytecode array length: 44
+bytecode array length: 43
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaZero),
@@ -336,15 +336,15 @@ bytecodes: [
   /*   53 S> */ B(LdaSmi), I8(1),
                 B(Star), R(1),
   /*   56 E> */ B(StackCheck),
-  /*   63 S> */ B(LdaSmi), I8(10),
-  /*   69 E> */ B(Mul), R(1), U8(2),
+  /*   63 S> */ B(Nop),
+  /*   69 E> */ B(MulSmi), I8(10), U8(2),
                 B(Star), R(1),
   /*   77 S> */ B(LdaSmi), I8(5),
   /*   83 E> */ B(TestEqual), R(0), U8(3),
                 B(JumpIfFalse), U8(4),
   /*   89 S> */ B(Jump), U8(18),
-  /*   98 S> */ B(LdaSmi), I8(1),
-  /*  104 E> */ B(Add), R(0), U8(4),
+  /*   98 S> */ B(Ldar), R(0),
+  /*  104 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
   /*  111 S> */ B(LdaSmi), I8(6),
   /*  117 E> */ B(TestEqual), R(0), U8(5),
@@ -379,15 +379,15 @@ bytecodes: [
   /*   53 S> */ B(LdaSmi), I8(1),
                 B(Star), R(1),
   /*   56 E> */ B(StackCheck),
-  /*   63 S> */ B(LdaSmi), I8(10),
-  /*   69 E> */ B(Mul), R(1), U8(2),
+  /*   63 S> */ B(Ldar), R(1),
+  /*   69 E> */ B(MulSmi), I8(10), U8(2),
                 B(Star), R(1),
   /*   77 S> */ B(LdaSmi), I8(5),
   /*   83 E> */ B(TestEqual), R(0), U8(3),
                 B(JumpIfFalse), U8(4),
   /*   89 S> */ B(Jump), U8(21),
-  /*   98 S> */ B(LdaSmi), I8(1),
-  /*  104 E> */ B(Add), R(0), U8(4),
+  /*   98 S> */ B(Ldar), R(0),
+  /*  104 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
   /*  111 S> */ B(LdaSmi), I8(6),
   /*  117 E> */ B(TestEqual), R(0), U8(5),
@@ -427,8 +427,8 @@ bytecodes: [
   /*   85 E> */ B(TestEqual), R(0), U8(3),
                 B(JumpIfFalse), U8(4),
   /*   91 S> */ B(Jump), U8(9),
-  /*  103 S> */ B(LdaSmi), I8(1),
-  /*  109 E> */ B(Add), R(0), U8(4),
+  /*  103 S> */ B(Ldar), R(0),
+  /*  109 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
                 B(JumpLoop), U8(26), I8(0),
                 B(LdaUndefined),
@@ -463,8 +463,8 @@ bytecodes: [
   /*   83 E> */ B(TestEqual), R(0), U8(3),
                 B(JumpIfFalse), U8(4),
   /*   89 S> */ B(Jump), U8(9),
-  /*  101 S> */ B(LdaSmi), I8(1),
-  /*  107 E> */ B(Add), R(0), U8(4),
+  /*  101 S> */ B(Ldar), R(0),
+  /*  107 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
                 B(JumpLoop), U8(26), I8(0),
                 B(LdaUndefined),
@@ -499,8 +499,8 @@ bytecodes: [
   /*   95 E> */ B(TestEqual), R(0), U8(4),
                 B(JumpIfFalse), U8(4),
   /*  101 S> */ B(Jump), U8(2),
-  /*   55 S> */ B(LdaSmi), I8(1),
-  /*   59 E> */ B(Add), R(0), U8(2),
+  /*   55 S> */ B(Ldar), R(0),
+  /*   59 E> */ B(AddSmi), I8(1), U8(2),
                 B(Star), R(0),
                 B(JumpLoop), U8(26), I8(0),
                 B(LdaUndefined),
@@ -534,8 +534,8 @@ bytecodes: [
   /*   93 E> */ B(TestEqual), R(0), U8(4),
                 B(JumpIfFalse), U8(4),
   /*   99 S> */ B(Jump), U8(2),
-  /*   53 S> */ B(LdaSmi), I8(1),
-  /*   57 E> */ B(Add), R(0), U8(2),
+  /*   53 S> */ B(Ldar), R(0),
+  /*   57 E> */ B(AddSmi), I8(1), U8(2),
                 B(Star), R(0),
                 B(JumpLoop), U8(26), I8(0),
                 B(LdaUndefined),
@@ -567,12 +567,12 @@ bytecodes: [
   /*   63 E> */ B(TestLessThan), R(1), U8(2),
                 B(JumpIfFalse), U8(22),
   /*   45 E> */ B(StackCheck),
-  /*   85 S> */ B(LdaSmi), I8(1),
-  /*   91 E> */ B(Add), R(0), U8(4),
+  /*   85 S> */ B(Ldar), R(0),
+  /*   91 E> */ B(AddSmi), I8(1), U8(4),
                 B(Star), R(0),
   /*   98 S> */ B(Jump), U8(2),
-  /*   72 S> */ B(LdaSmi), I8(1),
-  /*   76 E> */ B(Add), R(1), U8(3),
+  /*   72 S> */ B(Ldar), R(1),
+  /*   76 E> */ B(AddSmi), I8(1), U8(3),
                 B(Star), R(1),
                 B(JumpLoop), U8(24), I8(0),
                 B(LdaUndefined),
@@ -603,8 +603,8 @@ bytecodes: [
   /*   62 S> */ B(Ldar), R(1),
                 B(JumpIfToBooleanFalse), U8(19),
   /*   45 E> */ B(StackCheck),
-  /*   74 S> */ B(LdaSmi), I8(12),
-  /*   80 E> */ B(Mul), R(0), U8(3),
+  /*   74 S> */ B(Ldar), R(0),
+  /*   80 E> */ B(MulSmi), I8(12), U8(3),
                 B(Star), R(0),
   /*   67 S> */ B(Ldar), R(1),
                 B(Dec), U8(2),
@@ -662,8 +662,8 @@ bytecodes: [
   /*   58 S> */ B(LdaZero),
                 B(Star), R(1),
   /*   45 E> */ B(StackCheck),
-  /*   76 S> */ B(LdaSmi), I8(1),
-  /*   82 E> */ B(Add), R(0), U8(3),
+  /*   76 S> */ B(Ldar), R(0),
+  /*   82 E> */ B(AddSmi), I8(1), U8(3),
                 B(Star), R(0),
   /*   89 S> */ B(LdaSmi), I8(20),
   /*   95 E> */ B(TestEqual), R(0), U8(4),

test/cctest/interpreter/bytecode_expectations/BreakableBlocks.golden

@@ -17,13 +17,13 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 16
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaZero),
                 B(Star), R(0),
-  /*   56 S> */ B(LdaSmi), I8(1),
-  /*   62 E> */ B(Add), R(0), U8(2),
+  /*   56 S> */ B(Nop),
+  /*   62 E> */ B(AddSmi), I8(1), U8(2),
                 B(Star), R(0),
   /*   69 S> */ B(Jump), U8(2),
   /*   97 S> */ B(Ldar), R(0),

test/cctest/interpreter/bytecode_expectations/ClassAndSuperClass.golden

@@ -22,7 +22,7 @@ snippet: "
 "
 frame size: 6
 parameter count: 1
-bytecode array length: 36
+bytecode array length: 33
 bytecodes: [
                 B(Mov), R(closure), R(0),
   /*   99 E> */ B(StackCheck),
@@ -35,8 +35,7 @@ bytecodes: [
                 B(CallRuntime), U16(Runtime::kLoadFromSuper), R(3), U8(3),
                 B(Star), R(1),
   /*  117 E> */ B(Call0), R(1), R(this), U8(2),
-                B(Star), R(1),
-  /*  126 E> */ B(AddSmi), I8(1), R(1), U8(8),
+  /*  126 E> */ B(AddSmi), I8(1), U8(8),
   /*  131 S> */ B(Return),
 ]
 constant pool: [

test/cctest/interpreter/bytecode_expectations/CompoundExpressions.golden

@@ -9,15 +9,14 @@ wrap: yes
 snippet: "
   var a = 1; a += 2;
 "
-frame size: 2
+frame size: 1
 parameter count: 1
-bytecode array length: 16
+bytecode array length: 12
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   45 S> */ B(AddSmi), I8(2), R(0), U8(2),
-                B(Mov), R(0), R(1),
+  /*   45 S> */ B(AddSmi), I8(2), U8(2),
                 B(Star), R(0),
                 B(LdaUndefined),
   /*   53 S> */ B(Return),
@@ -31,16 +30,14 @@ handlers: [
 snippet: "
   var a = 1; a /= 2;
 "
-frame size: 2
+frame size: 1
 parameter count: 1
-bytecode array length: 17
+bytecode array length: 12
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   45 S> */ B(LdaSmi), I8(2),
-                B(Div), R(0), U8(2),
-                B(Mov), R(0), R(1),
+  /*   45 S> */ B(DivSmi), I8(2), U8(2),
                 B(Star), R(0),
                 B(LdaUndefined),
   /*   53 S> */ B(Return),
@@ -54,17 +51,15 @@ handlers: [
 snippet: "
   var a = { val: 2 }; a.name *= 2;
 "
-frame size: 3
+frame size: 2
 parameter count: 1
-bytecode array length: 26
+bytecode array length: 22
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(CreateObjectLiteral), U8(0), U8(2), U8(1), R(1),
                 B(Mov), R(1), R(0),
   /*   54 S> */ B(LdaNamedProperty), R(0), U8(1), U8(3),
-                B(Star), R(2),
-                B(LdaSmi), I8(2),
-                B(Mul), R(2), U8(5),
+                B(MulSmi), I8(2), U8(5),
   /*   61 E> */ B(StaNamedPropertySloppy), R(0), U8(1), U8(6),
                 B(LdaUndefined),
   /*   67 S> */ B(Return),
@@ -80,9 +75,9 @@ handlers: [
 snippet: "
   var a = { 1: 2 }; a[1] ^= 2;
 "
-frame size: 4
+frame size: 3
 parameter count: 1
-bytecode array length: 29
+bytecode array length: 25
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(CreateObjectLiteral), U8(0), U8(2), U8(1), R(1),
@@ -90,9 +85,7 @@ bytecodes: [
   /*   52 S> */ B(LdaSmi), I8(1),
                 B(Star), R(2),
                 B(LdaKeyedProperty), R(0), U8(3),
-                B(Star), R(3),
-                B(LdaSmi), I8(2),
-                B(BitwiseXor), R(3), U8(5),
+                B(BitwiseXorSmi), I8(2), U8(5),
   /*   57 E> */ B(StaKeyedPropertySloppy), R(0), R(2), U8(6),
                 B(LdaUndefined),
   /*   63 S> */ B(Return),
@@ -107,9 +100,9 @@ handlers: [
 snippet: "
   var a = 1; (function f() { return a; }); a |= 24;
 "
-frame size: 2
+frame size: 1
 parameter count: 1
-bytecode array length: 25
+bytecode array length: 22
 bytecodes: [
                 B(CreateFunctionContext), U8(1),
                 B(PushContext), R(0),
@@ -118,8 +111,7 @@ bytecodes: [
   /*   42 E> */ B(StaCurrentContextSlot), U8(4),
   /*   45 S> */ B(CreateClosure), U8(0), U8(2), U8(2),
   /*   75 S> */ B(LdaCurrentContextSlot), U8(4),
-                B(Star), R(1),
-                B(BitwiseOrSmi), I8(24), R(1), U8(3),
+                B(BitwiseOrSmi), I8(24), U8(3),
   /*   77 E> */ B(StaCurrentContextSlot), U8(4),
                 B(LdaUndefined),
   /*   84 S> */ B(Return),

test/cctest/interpreter/bytecode_expectations/GlobalCompoundExpressions.golden

@@ -12,14 +12,13 @@ snippet: "
   function f() { return global &= 1; }
   f();
 "
-frame size: 1
+frame size: 0
 parameter count: 1
-bytecode array length: 14
+bytecode array length: 11
 bytecodes: [
   /*   26 E> */ B(StackCheck),
   /*   31 S> */ B(LdaGlobal), U8(0), U8(2),
-                B(Star), R(0),
-                B(BitwiseAndSmi), I8(1), R(0), U8(4),
+                B(BitwiseAndSmi), I8(1), U8(4),
   /*   45 E> */ B(StaGlobalSloppy), U8(0), U8(5),
   /*   51 S> */ B(Return),
 ]
@@ -35,14 +34,13 @@ snippet: "
   function f() { return unallocated += 1; }
   f();
 "
-frame size: 1
+frame size: 0
 parameter count: 1
-bytecode array length: 14
+bytecode array length: 11
 bytecodes: [
   /*   27 E> */ B(StackCheck),
   /*   32 S> */ B(LdaGlobal), U8(0), U8(2),
-                B(Star), R(0),
-                B(AddSmi), I8(1), R(0), U8(4),
+                B(AddSmi), I8(1), U8(4),
   /*   51 E> */ B(StaGlobalSloppy), U8(0), U8(5),
   /*   57 S> */ B(Return),
 ]

test/cctest/interpreter/bytecode_expectations/IfConditions.golden

@@ -112,16 +112,16 @@ snippet: "
   };
   f();
 "
-frame size: 2
+frame size: 1
 parameter count: 1
-bytecode array length: 23
+bytecode array length: 21
 bytecodes: [
   /*   10 E> */ B(StackCheck),
   /*   25 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   30 S> */ B(JumpIfToBooleanFalse), U8(13),
-  /*   43 S> */ B(AddSmi), I8(1), R(0), U8(2),
-                B(Mov), R(0), R(1),
+  /*   30 S> */ B(JumpIfToBooleanFalse), U8(11),
+  /*   43 S> */ B(Ldar), R(0),
+                B(AddSmi), I8(1), U8(2),
                 B(Star), R(0),
                 B(Jump), U8(5),
   /*   66 S> */ B(LdaSmi), I8(2),

test/cctest/interpreter/bytecode_expectations/ObjectLiterals.golden

@@ -72,13 +72,13 @@ snippet: "
 "
 frame size: 2
 parameter count: 1
-bytecode array length: 21
+bytecode array length: 20
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
   /*   45 S> */ B(CreateObjectLiteral), U8(0), U8(3), U8(1), R(1),
-  /*   69 E> */ B(AddSmi), I8(1), R(0), U8(2),
+  /*   69 E> */ B(AddSmi), I8(1), U8(2),
                 B(StaNamedOwnProperty), R(1), U8(1), U8(4),
                 B(Ldar), R(1),
   /*   76 S> */ B(Return),

test/cctest/interpreter/bytecode_expectations/PrimitiveExpressions.golden

@@ -30,13 +30,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaZero),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(AddSmi), I8(3), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 0; return 3 + x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 14
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaZero),
                 B(Star), R(0),
   /*   45 S> */ B(LdaSmi), I8(3),
-  /*   54 E> */ B(Add), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   54 E> */ B(Add), R(1), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -50,13 +72,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 10
+bytecode array length: 9
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaZero),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(SubSmi), I8(3), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 0; return 3 - x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 14
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaZero),
                 B(Star), R(0),
   /*   45 S> */ B(LdaSmi), I8(3),
-  /*   54 E> */ B(Sub), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   54 E> */ B(Sub), R(1), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -70,13 +114,33 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(4),
                 B(Star), R(0),
-  /*   45 S> */ B(LdaSmi), I8(3),
-  /*   54 E> */ B(Mul), R(0), U8(2),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(MulSmi), I8(3), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 4; return 3 * x;
+"
+frame size: 1
+parameter count: 1
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(4),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(MulSmi), I8(3), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -90,13 +154,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(4),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(DivSmi), I8(3), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 4; return 3 / x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(4),
                 B(Star), R(0),
   /*   45 S> */ B(LdaSmi), I8(3),
-  /*   54 E> */ B(Div), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   54 E> */ B(Div), R(1), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -110,13 +196,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(4),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(ModSmi), I8(3), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 4; return 3 % x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(4),
                 B(Star), R(0),
   /*   45 S> */ B(LdaSmi), I8(3),
-  /*   54 E> */ B(Mod), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   54 E> */ B(Mod), R(1), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -130,13 +238,33 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   45 S> */ B(LdaSmi), I8(2),
-  /*   54 E> */ B(BitwiseOr), R(0), U8(2),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseOrSmi), I8(2), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 1; return 2 | x;
+"
+frame size: 1
+parameter count: 1
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(1),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseOrSmi), I8(2), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -150,13 +278,33 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   45 S> */ B(LdaSmi), I8(2),
-  /*   54 E> */ B(BitwiseXor), R(0), U8(2),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseXorSmi), I8(2), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 1; return 2 ^ x;
+"
+frame size: 1
+parameter count: 1
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(1),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseXorSmi), I8(2), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -170,13 +318,33 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(1),
+                B(Star), R(0),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseAndSmi), I8(2), U8(2),
+  /*   59 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 1; return 2 & x;
+"
+frame size: 1
+parameter count: 1
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
                 B(Star), R(0),
-  /*   45 S> */ B(LdaSmi), I8(2),
-  /*   54 E> */ B(BitwiseAnd), R(0), U8(2),
+  /*   45 S> */ B(Nop),
+  /*   54 E> */ B(BitwiseAndSmi), I8(2), U8(2),
   /*   59 S> */ B(Return),
 ]
 constant pool: [
@@ -190,13 +358,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(10),
+                B(Star), R(0),
+  /*   46 S> */ B(Nop),
+  /*   55 E> */ B(ShiftLeftSmi), I8(3), U8(2),
+  /*   61 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 10; return 3 << x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(10),
                 B(Star), R(0),
   /*   46 S> */ B(LdaSmi), I8(3),
-  /*   55 E> */ B(ShiftLeft), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   55 E> */ B(ShiftLeft), R(1), U8(2),
   /*   61 S> */ B(Return),
 ]
 constant pool: [
@@ -210,13 +400,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(10),
+                B(Star), R(0),
+  /*   46 S> */ B(Nop),
+  /*   55 E> */ B(ShiftRightSmi), I8(3), U8(2),
+  /*   61 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 10; return 3 >> x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(10),
                 B(Star), R(0),
   /*   46 S> */ B(LdaSmi), I8(3),
-  /*   55 E> */ B(ShiftRight), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   55 E> */ B(ShiftRight), R(1), U8(2),
   /*   61 S> */ B(Return),
 ]
 constant pool: [
@@ -230,13 +442,35 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
+bytecodes: [
+  /*   30 E> */ B(StackCheck),
+  /*   42 S> */ B(LdaSmi), I8(10),
+                B(Star), R(0),
+  /*   46 S> */ B(Nop),
+  /*   55 E> */ B(ShiftRightLogicalSmi), I8(3), U8(2),
+  /*   62 S> */ B(Return),
+]
+constant pool: [
+]
+handlers: [
+]
+
+---
+snippet: "
+  var x = 10; return 3 >>> x;
+"
+frame size: 2
+parameter count: 1
+bytecode array length: 15
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(10),
                 B(Star), R(0),
   /*   46 S> */ B(LdaSmi), I8(3),
-  /*   55 E> */ B(ShiftRightLogical), R(0), U8(2),
+                B(Star), R(1),
+                B(Ldar), R(0),
+  /*   55 E> */ B(ShiftRightLogical), R(1), U8(2),
   /*   62 S> */ B(Return),
 ]
 constant pool: [

test/cctest/interpreter/bytecode_expectations/Switch.golden

@@ -479,7 +479,7 @@ snippet: "
 "
 frame size: 5
 parameter count: 1
-bytecode array length: 62
+bytecode array length: 63
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(1),
@@ -491,9 +491,10 @@ bytecodes: [
                 B(JumpIfTrue), U8(11),
                 B(LdaSmi), I8(2),
                 B(TestEqualStrict), R(3), U8(6),
-                B(JumpIfTrue), U8(34),
-                B(Jump), U8(36),
-  /*   79 E> */ B(AddSmi), I8(1), R(0), U8(2),
+                B(JumpIfTrue), U8(35),
+                B(Jump), U8(37),
+                B(Ldar), R(0),
+  /*   79 E> */ B(AddSmi), I8(1), U8(2),
                 B(Star), R(1),
   /*   70 S> */ B(LdaSmi), I8(2),
                 B(TestEqualStrict), R(1), U8(3),

test/cctest/interpreter/bytecode_expectations/UnaryOperators.golden

@@ -24,8 +24,8 @@ bytecodes: [
   /*   54 E> */ B(TestEqual), R(0), U8(2),
                 B(JumpIfTrue), U8(13),
   /*   45 E> */ B(StackCheck),
-  /*   65 S> */ B(LdaSmi), I8(10),
-  /*   71 E> */ B(Add), R(0), U8(3),
+  /*   65 S> */ B(Ldar), R(0),
+  /*   71 E> */ B(AddSmi), I8(10), U8(3),
                 B(Star), R(0),
                 B(JumpLoop), U8(15), I8(0),
   /*   79 S> */ B(Ldar), R(0),
@@ -74,13 +74,13 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 12
+bytecode array length: 11
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(101),
                 B(Star), R(0),
-  /*   47 S> */ B(LdaSmi), I8(3),
-  /*   61 E> */ B(Mul), R(0), U8(2),
+  /*   47 S> */ B(Nop),
+  /*   61 E> */ B(MulSmi), I8(3), U8(2),
                 B(LdaUndefined),
   /*   67 S> */ B(Return),
 ]
@@ -95,17 +95,16 @@ snippet: "
   var y = void (x * x - 1);
   return y;
 "
-frame size: 3
+frame size: 2
 parameter count: 1
-bytecode array length: 22
+bytecode array length: 19
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(Wide), B(LdaSmi), I16(1234),
                 B(Star), R(0),
   /*   56 S> */ B(Nop),
   /*   64 E> */ B(Mul), R(0), U8(2),
-                B(Star), R(2),
-  /*   68 E> */ B(SubSmi), I8(1), R(2), U8(3),
+  /*   68 E> */ B(SubSmi), I8(1), U8(3),
                 B(LdaUndefined),
                 B(Star), R(1),
   /*   74 S> */ B(Nop),
@@ -123,13 +122,13 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(13),
                 B(Star), R(0),
-  /*   46 S> */ B(LdaSmi), I8(-1),
-  /*   53 E> */ B(BitwiseXor), R(0), U8(2),
+  /*   46 S> */ B(Nop),
+  /*   53 E> */ B(BitwiseXorSmi), I8(-1), U8(2),
   /*   57 S> */ B(Return),
 ]
 constant pool: [
@@ -144,13 +143,13 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(13),
                 B(Star), R(0),
-  /*   46 S> */ B(LdaSmi), I8(1),
-  /*   53 E> */ B(Mul), R(0), U8(2),
+  /*   46 S> */ B(Nop),
+  /*   53 E> */ B(MulSmi), I8(1), U8(2),
   /*   57 S> */ B(Return),
 ]
 constant pool: [
@@ -165,13 +164,13 @@ snippet: "
 "
 frame size: 1
 parameter count: 1
-bytecode array length: 11
+bytecode array length: 10
 bytecodes: [
   /*   30 E> */ B(StackCheck),
   /*   42 S> */ B(LdaSmi), I8(13),
                 B(Star), R(0),
-  /*   46 S> */ B(LdaSmi), I8(-1),
-  /*   53 E> */ B(Mul), R(0), U8(2),
+  /*   46 S> */ B(Nop),
+  /*   53 E> */ B(MulSmi), I8(-1), U8(2),
   /*   57 S> */ B(Return),
 ]
 constant pool: [

test/cctest/interpreter/test-bytecode-generator.cc

@@ -190,26 +190,48 @@ TEST(PrimitiveExpressions) {
 
       "var x = 0; return x + 3;\n",
 
+      "var x = 0; return 3 + x;\n",
+
       "var x = 0; return x - 3;\n",
 
+      "var x = 0; return 3 - x;\n",
+
       "var x = 4; return x * 3;\n",
 
+      "var x = 4; return 3 * x;\n",
+
       "var x = 4; return x / 3;\n",
 
+      "var x = 4; return 3 / x;\n",
+
       "var x = 4; return x % 3;\n",
 
+      "var x = 4; return 3 % x;\n",
+
       "var x = 1; return x | 2;\n",
 
+      "var x = 1; return 2 | x;\n",
+
       "var x = 1; return x ^ 2;\n",
 
+      "var x = 1; return 2 ^ x;\n",
+
       "var x = 1; return x & 2;\n",
 
+      "var x = 1; return 2 & x;\n",
+
       "var x = 10; return x << 3;\n",
 
+      "var x = 10; return 3 << x;\n",
+
       "var x = 10; return x >> 3;\n",
 
+      "var x = 10; return 3 >> x;\n",
+
       "var x = 10; return x >>> 3;\n",
 
+      "var x = 10; return 3 >>> x;\n",
+
       "var x = 0; return (x, 3);\n",
   };
 

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

@@ -177,19 +177,18 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
       .BinaryOperation(Token::Value::SAR, reg, 10)
       .BinaryOperation(Token::Value::SHR, reg, 11);
 
-  // Emit peephole optimizations of LdaSmi followed by binary operation.
-  builder.LoadLiteral(Smi::FromInt(1))
-      .BinaryOperation(Token::Value::ADD, reg, 1)
-      .LoadLiteral(Smi::FromInt(2))
-      .BinaryOperation(Token::Value::SUB, reg, 2)
-      .LoadLiteral(Smi::FromInt(3))
-      .BinaryOperation(Token::Value::BIT_AND, reg, 3)
-      .LoadLiteral(Smi::FromInt(4))
-      .BinaryOperation(Token::Value::BIT_OR, reg, 4)
-      .LoadLiteral(Smi::FromInt(5))
-      .BinaryOperation(Token::Value::SHL, reg, 5)
-      .LoadLiteral(Smi::FromInt(6))
-      .BinaryOperation(Token::Value::SAR, reg, 6);
+  // Emit Smi binary operations.
+  builder.BinaryOperationSmiLiteral(Token::Value::ADD, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::SUB, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::MUL, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::DIV, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::MOD, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::BIT_OR, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::BIT_XOR, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::BIT_AND, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::SHL, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::SAR, Smi::FromInt(42), 2)
+      .BinaryOperationSmiLiteral(Token::Value::SHR, Smi::FromInt(42), 2);
 
   // Emit count operatior invocations
   builder.CountOperation(Token::Value::ADD, 1)
@@ -421,12 +420,6 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
 
   if (!FLAG_ignition_peephole) {
     // Insert entries for bytecodes only emitted by peephole optimizer.
-    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;
   }
 
   if (!FLAG_type_profile) {

test/unittests/interpreter/bytecode-peephole-optimizer-unittest.cc

@@ -165,88 +165,6 @@ TEST_F(BytecodePeepholeOptimizerTest, LdaTrueStatementLdaFalse) {
 
 // Tests covering BytecodePeepholeOptimizer::UpdateLastAndCurrentBytecodes().
 
-TEST_F(BytecodePeepholeOptimizerTest, MergeLdaSmiWithBinaryOp) {
-  Bytecode operator_replacement_pairs[][2] = {
-      {Bytecode::kAdd, Bytecode::kAddSmi},
-      {Bytecode::kSub, Bytecode::kSubSmi},
-      {Bytecode::kBitwiseAnd, Bytecode::kBitwiseAndSmi},
-      {Bytecode::kBitwiseOr, Bytecode::kBitwiseOrSmi},
-      {Bytecode::kShiftLeft, Bytecode::kShiftLeftSmi},
-      {Bytecode::kShiftRight, Bytecode::kShiftRightSmi}};
-
-  for (auto operator_replacement : operator_replacement_pairs) {
-    uint32_t imm_operand = 17;
-    BytecodeSourceInfo source_info(3, true);
-    BytecodeNode first(Bytecode::kLdaSmi, imm_operand, source_info);
-    uint32_t reg_operand = Register(0).ToOperand();
-    uint32_t idx_operand = 1;
-    BytecodeNode second(operator_replacement[0], reg_operand, idx_operand);
-    optimizer()->Write(&first);
-    optimizer()->Write(&second);
-    Flush();
-    CHECK_EQ(write_count(), 1);
-    CHECK_EQ(last_written().bytecode(), operator_replacement[1]);
-    CHECK_EQ(last_written().operand_count(), 3);
-    CHECK_EQ(last_written().operand(0), imm_operand);
-    CHECK_EQ(last_written().operand(1), reg_operand);
-    CHECK_EQ(last_written().operand(2), idx_operand);
-    CHECK_EQ(last_written().source_info(), source_info);
-    Reset();
-  }
-}
-
-TEST_F(BytecodePeepholeOptimizerTest, NotMergingLdaSmiWithBinaryOp) {
-  Bytecode operator_replacement_pairs[][2] = {
-      {Bytecode::kAdd, Bytecode::kAddSmi},
-      {Bytecode::kSub, Bytecode::kSubSmi},
-      {Bytecode::kBitwiseAnd, Bytecode::kBitwiseAndSmi},
-      {Bytecode::kBitwiseOr, Bytecode::kBitwiseOrSmi},
-      {Bytecode::kShiftLeft, Bytecode::kShiftLeftSmi},
-      {Bytecode::kShiftRight, Bytecode::kShiftRightSmi}};
-
-  for (auto operator_replacement : operator_replacement_pairs) {
-    uint32_t imm_operand = 17;
-    BytecodeSourceInfo source_info(3, true);
-    BytecodeNode first(Bytecode::kLdaSmi, imm_operand, source_info);
-    uint32_t reg_operand = Register(0).ToOperand();
-    source_info.MakeStatementPosition(4);
-    BytecodeNode second(operator_replacement[0], reg_operand, 1, source_info);
-    optimizer()->Write(&first);
-    optimizer()->Write(&second);
-    CHECK_EQ(last_written(), first);
-    Flush();
-    CHECK_EQ(last_written(), second);
-    Reset();
-  }
-}
-
-TEST_F(BytecodePeepholeOptimizerTest, MergeLdaZeroWithBinaryOp) {
-  Bytecode operator_replacement_pairs[][2] = {
-      {Bytecode::kAdd, Bytecode::kAddSmi},
-      {Bytecode::kSub, Bytecode::kSubSmi},
-      {Bytecode::kBitwiseAnd, Bytecode::kBitwiseAndSmi},
-      {Bytecode::kBitwiseOr, Bytecode::kBitwiseOrSmi},
-      {Bytecode::kShiftLeft, Bytecode::kShiftLeftSmi},
-      {Bytecode::kShiftRight, Bytecode::kShiftRightSmi}};
-
-  for (auto operator_replacement : operator_replacement_pairs) {
-    BytecodeNode first(Bytecode::kLdaZero);
-    uint32_t reg_operand = Register(0).ToOperand();
-    uint32_t idx_operand = 1;
-    BytecodeNode second(operator_replacement[0], reg_operand, idx_operand);
-    optimizer()->Write(&first);
-    optimizer()->Write(&second);
-    Flush();
-    CHECK_EQ(write_count(), 1);
-    CHECK_EQ(last_written().bytecode(), operator_replacement[1]);
-    CHECK_EQ(last_written().operand_count(), 3);
-    CHECK_EQ(last_written().operand(0), 0u);
-    CHECK_EQ(last_written().operand(1), reg_operand);
-    CHECK_EQ(last_written().operand(2), idx_operand);
-    Reset();
-  }
-}
-
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8