[interpreter] Create custom call opcodes for specific argument counts

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 <cstdint>
 #include <iosfwd>
 #include <string>
@@ skipping 131 matching lines @@
   V(TypeOf, AccumulatorUse::kReadWrite)                                       \
   V(DeletePropertyStrict, AccumulatorUse::kReadWrite, OperandType::kReg)      \
   V(DeletePropertySloppy, AccumulatorUse::kReadWrite, OperandType::kReg)      \
                                                                               \
   /* GetSuperConstructor operator */                                          \
   V(GetSuperConstructor, AccumulatorUse::kRead, OperandType::kRegOut)         \
                                                                               \
   /* Call operations */                                                       \
   V(Call, AccumulatorUse::kWrite, OperandType::kReg, OperandType::kRegList,   \
     OperandType::kRegCount, OperandType::kIdx)                                \
+  V(Call0, AccumulatorUse::kWrite, OperandType::kReg, OperandType::kReg,      \
+    OperandType::kIdx)                                                        \
+  V(Call1, AccumulatorUse::kWrite, OperandType::kReg, OperandType::kReg,      \
+    OperandType::kReg, OperandType::kIdx)                                     \
+  V(Call2, AccumulatorUse::kWrite, OperandType::kReg, OperandType::kReg,      \
+    OperandType::kReg, OperandType::kReg, OperandType::kIdx)                  \
   V(CallProperty, AccumulatorUse::kWrite, OperandType::kReg,                  \
     OperandType::kRegList, OperandType::kRegCount, OperandType::kIdx)         \
+  V(CallProperty0, AccumulatorUse::kWrite, OperandType::kReg,                 \
+    OperandType::kReg, OperandType::kIdx)                                     \
+  V(CallProperty1, AccumulatorUse::kWrite, OperandType::kReg,                 \
+    OperandType::kReg, OperandType::kReg, OperandType::kIdx)                  \
+  V(CallProperty2, AccumulatorUse::kWrite, OperandType::kReg,                 \
+    OperandType::kReg, OperandType::kReg, OperandType::kReg,                  \
+    OperandType::kIdx)                                                        \
   V(CallWithSpread, AccumulatorUse::kWrite, OperandType::kReg,                \
     OperandType::kRegList, OperandType::kRegCount)                            \
   V(TailCall, AccumulatorUse::kWrite, OperandType::kReg,                      \
     OperandType::kRegList, OperandType::kRegCount, OperandType::kIdx)         \
   V(CallRuntime, AccumulatorUse::kWrite, OperandType::kRuntimeId,             \
     OperandType::kRegList, OperandType::kRegCount)                            \
   V(CallRuntimeForPair, AccumulatorUse::kNone, OperandType::kRuntimeId,       \
     OperandType::kRegList, OperandType::kRegCount, OperandType::kRegOutPair)  \
   V(CallJSRuntime, AccumulatorUse::kWrite, OperandType::kIdx,                 \
     OperandType::kRegList, OperandType::kRegCount)                            \
@@ skipping 231 matching lines @@
 #define COUNT_BYTECODE(x, ...) +1
   // The COUNT_BYTECODE macro will turn this into kLast = -1 +1 +1... which will
   // evaluate to the same value as the last real bytecode.
   kLast = -1 BYTECODE_LIST(COUNT_BYTECODE)
 #undef COUNT_BYTECODE
 };
 
 class V8_EXPORT_PRIVATE Bytecodes final {
  public:
   //  The maximum number of operands a bytecode may have.
-  static const int kMaxOperands = 4;
+  static const int kMaxOperands = 5;
 
   // Returns string representation of |bytecode|.
   static const char* ToString(Bytecode bytecode);
 
   // Returns string representation of |bytecode|.
   static std::string ToString(Bytecode bytecode, OperandScale operand_scale);
 
   // Returns byte value of bytecode.
   static uint8_t ToByte(Bytecode bytecode) {
     DCHECK_LE(bytecode, Bytecode::kLast);
@@ skipping 190 matching lines @@
     return bytecode == Bytecode::kLdar || bytecode == Bytecode::kStar;
   }
 
   // Returns true if |bytecode| puts a name in the accumulator.
   static constexpr bool PutsNameInAccumulator(Bytecode bytecode) {
     return bytecode == Bytecode::kTypeOf;
   }
 
   // Returns true if the bytecode is a call or a constructor call.
   static constexpr bool IsCallOrConstruct(Bytecode bytecode) {
-    return bytecode == Bytecode::kCall || bytecode == Bytecode::kCallProperty ||
+    return bytecode == Bytecode::kCall || bytecode == Bytecode::kCall0 ||
+           bytecode == Bytecode::kCall1 || bytecode == Bytecode::kCall2 ||
+           bytecode == Bytecode::kCallProperty ||
+           bytecode == Bytecode::kCallProperty0 ||
+           bytecode == Bytecode::kCallProperty1 ||
+           bytecode == Bytecode::kCallProperty2 ||
            bytecode == Bytecode::kTailCall || bytecode == Bytecode::kConstruct;
   }
 
   // Returns true if the bytecode is a call to the runtime.
   static constexpr bool IsCallRuntime(Bytecode bytecode) {
     return bytecode == Bytecode::kCallRuntime ||
            bytecode == Bytecode::kCallRuntimeForPair ||
            bytecode == Bytecode::kInvokeIntrinsic;
   }
 
@@ skipping 191 matching lines @@
 };
 
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            const Bytecode& bytecode);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_