[interpreter] Introduce binary op bytecodes for Smi operand.

src/interpreter/bytecodes.h

 // 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.
 
 #ifndef V8_INTERPRETER_BYTECODES_H_
 #define V8_INTERPRETER_BYTECODES_H_
 
 #include <iosfwd>
 
 // Clients of this interface shouldn't depend on lots of interpreter internals.
@@ skipping 139 matching lines @@
   V(Mul, AccumulatorUse::kReadWrite, OperandType::kReg)                        \
   V(Div, AccumulatorUse::kReadWrite, OperandType::kReg)                        \
   V(Mod, AccumulatorUse::kReadWrite, OperandType::kReg)                        \
   V(BitwiseOr, AccumulatorUse::kReadWrite, OperandType::kReg)                  \
   V(BitwiseXor, AccumulatorUse::kReadWrite, OperandType::kReg)                 \
   V(BitwiseAnd, AccumulatorUse::kReadWrite, OperandType::kReg)                 \
   V(ShiftLeft, AccumulatorUse::kReadWrite, OperandType::kReg)                  \
   V(ShiftRight, AccumulatorUse::kReadWrite, OperandType::kReg)                 \
   V(ShiftRightLogical, AccumulatorUse::kReadWrite, OperandType::kReg)          \
                                                                                \
+  /* Binary operators with immediate operands */                               \
+  V(AddSmi, AccumulatorUse::kWrite, OperandType::kImm, OperandType::kReg)      \
+  V(SubSmi, AccumulatorUse::kWrite, OperandType::kImm, OperandType::kReg)      \
+  V(BitwiseOrSmi, AccumulatorUse::kWrite, OperandType::kImm,                   \
+    OperandType::kReg)                                                         \
+  V(BitwiseAndSmi, AccumulatorUse::kWrite, OperandType::kImm,                  \
+    OperandType::kReg)                                                         \
+  V(ShiftLeftSmi, AccumulatorUse::kWrite, OperandType::kImm,                   \
+    OperandType::kReg)                                                         \
+  V(ShiftRightSmi, AccumulatorUse::kWrite, OperandType::kImm,                  \
+    OperandType::kReg)                                                         \
+                                                                               \
   /* Unary Operators */                                                        \
   V(Inc, AccumulatorUse::kReadWrite)                                           \
   V(Dec, AccumulatorUse::kReadWrite)                                           \
   V(ToBooleanLogicalNot, AccumulatorUse::kReadWrite)                           \
   V(LogicalNot, AccumulatorUse::kReadWrite)                                    \
   V(TypeOf, AccumulatorUse::kReadWrite)                                        \
   V(DeletePropertyStrict, AccumulatorUse::kReadWrite, OperandType::kReg)       \
   V(DeletePropertySloppy, AccumulatorUse::kReadWrite, OperandType::kReg)       \
                                                                                \
   /* Call operations */                                                        \
@@ skipping 415 matching lines @@
 
   // Returns true if the bytecode is a call to the runtime.
   static bool IsCallRuntime(Bytecode bytecode);
 
   // Returns true if the bytecode is a debug break.
   static bool IsDebugBreak(Bytecode bytecode);
 
   // Returns true if the bytecode is Ldar or Star.
   static bool IsLdarOrStar(Bytecode bytecode);
 
+  // Returns true if the bytecode is LdaSmi or LdaZero.
+  static bool IsLdaSmiOrLdaZero(Bytecode bytecode);
+
   // Returns true if the bytecode has wider operand forms.
   static bool IsBytecodeWithScalableOperands(Bytecode bytecode);
 
   // Returns true if the bytecode is a scaling prefix bytecode.
   static bool IsPrefixScalingBytecode(Bytecode bytecode);
 
   // Returns true if |operand_type| is any type of register operand.
   static bool IsRegisterOperandType(OperandType operand_type);
 
   // Returns true if |operand_type| represents a register used as an input.
@@ skipping 79 matching lines @@
 std::ostream& operator<<(std::ostream& os, const AccumulatorUse& use);
 std::ostream& operator<<(std::ostream& os, const OperandScale& operand_scale);
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_size);
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_