[interpreter] Create custom call opcodes for specific argument counts

src/interpreter/bytecode-pipeline.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_BYTECODE_PIPELINE_H_
 #define V8_INTERPRETER_BYTECODE_PIPELINE_H_
 
 #include "src/base/compiler-specific.h"
 #include "src/globals.h"
 #include "src/interpreter/bytecode-register-allocator.h"
@@ skipping 173 matching lines @@
         operand_count_(4),
         operand_scale_(OperandScale::kSingle),
         source_info_(source_info) {
     DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), operand_count());
     SetOperand(0, operand0);
     SetOperand(1, operand1);
     SetOperand(2, operand2);
     SetOperand(3, operand3);
   }
 
+  INLINE(BytecodeNode(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
+                      uint32_t operand2, uint32_t operand3, uint32_t operand4,
+                      BytecodeSourceInfo source_info = BytecodeSourceInfo()))
+      : bytecode_(bytecode),
+        operand_count_(5),
+        operand_scale_(OperandScale::kSingle),
+        source_info_(source_info) {
+    DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), operand_count());
+    SetOperand(0, operand0);
+    SetOperand(1, operand1);
+    SetOperand(2, operand2);
+    SetOperand(3, operand3);
+    SetOperand(4, operand4);
+  }
+
 #define DEFINE_BYTECODE_NODE_CREATOR(Name, ...)                              \
   template <typename... Operands>                                            \
   INLINE(static BytecodeNode Name(BytecodeSourceInfo source_info,            \
                                   Operands... operands)) {                   \
     return Create<Bytecode::k##Name, __VA_ARGS__>(source_info, operands...); \
   }
   BYTECODE_LIST(DEFINE_BYTECODE_NODE_CREATOR)
 #undef DEFINE_BYTECODE_NODE_CREATOR
 
   // Replace the bytecode of this node with |bytecode| and keep the operands.
@@ skipping 50 matching lines @@
 
  private:
   template <Bytecode bytecode, AccumulatorUse accumulator_use,
             OperandType... operand_types>
   friend class BytecodeNodeBuilder;
 
   INLINE(BytecodeNode(Bytecode bytecode, int operand_count,
                       OperandScale operand_scale,
                       BytecodeSourceInfo source_info, uint32_t operand0 = 0,
                       uint32_t operand1 = 0, uint32_t operand2 = 0,
-                      uint32_t operand3 = 0))
+                      uint32_t operand3 = 0, uint32_t operand4 = 0))
       : bytecode_(bytecode),
         operand_count_(operand_count),
         operand_scale_(operand_scale),
         source_info_(source_info) {
     DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), operand_count);
     operands_[0] = operand0;
     operands_[1] = operand1;
     operands_[2] = operand2;
     operands_[3] = operand3;
+    operands_[4] = operand4;
   }
 
   template <Bytecode bytecode, AccumulatorUse accum_use>
   INLINE(static BytecodeNode Create(BytecodeSourceInfo source_info)) {
     return BytecodeNode(bytecode, 0, OperandScale::kSingle, source_info);
   }
 
   template <Bytecode bytecode, AccumulatorUse accum_use,
             OperandType operand0_type>
   INLINE(static BytecodeNode Create(BytecodeSourceInfo source_info,
@@ skipping 45 matching lines @@
     DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 3), operand3_type);
     OperandScale scale = OperandScale::kSingle;
     scale = std::max(scale, ScaleForOperand<operand0_type>(operand0));
     scale = std::max(scale, ScaleForOperand<operand1_type>(operand1));
     scale = std::max(scale, ScaleForOperand<operand2_type>(operand2));
     scale = std::max(scale, ScaleForOperand<operand3_type>(operand3));
     return BytecodeNode(bytecode, 4, scale, source_info, operand0, operand1,
                         operand2, operand3);
   }
 
+  template <Bytecode bytecode, AccumulatorUse accum_use,
+            OperandType operand0_type, OperandType operand1_type,
+            OperandType operand2_type, OperandType operand3_type,
+            OperandType operand4_type>
+  INLINE(static BytecodeNode Create(BytecodeSourceInfo source_info,
+                                    uint32_t operand0, uint32_t operand1,
+                                    uint32_t operand2, uint32_t operand3,
+                                    uint32_t operand4)) {
+    DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 0), operand0_type);
+    DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 1), operand1_type);
+    DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 2), operand2_type);
+    DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 3), operand3_type);
+    DCHECK_EQ(Bytecodes::GetOperandType(bytecode, 4), operand4_type);
+    OperandScale scale = OperandScale::kSingle;
+    scale = std::max(scale, ScaleForOperand<operand0_type>(operand0));
+    scale = std::max(scale, ScaleForOperand<operand1_type>(operand1));
+    scale = std::max(scale, ScaleForOperand<operand2_type>(operand2));
+    scale = std::max(scale, ScaleForOperand<operand3_type>(operand3));
+    scale = std::max(scale, ScaleForOperand<operand4_type>(operand4));
+    return BytecodeNode(bytecode, 5, scale, source_info, operand0, operand1,
+                        operand2, operand3, operand4);
+  }
+
   template <OperandType operand_type>
   INLINE(static OperandScale ScaleForOperand(uint32_t operand)) {
     if (BytecodeOperands::IsScalableUnsignedByte(operand_type)) {
       return Bytecodes::ScaleForUnsignedOperand(operand);
     } else if (BytecodeOperands::IsScalableSignedByte(operand_type)) {
       return Bytecodes::ScaleForSignedOperand(operand);
     } else {
       return OperandScale::kSingle;
     }
   }
@@ skipping 24 matching lines @@
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            const BytecodeSourceInfo& info);
 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
                                            const BytecodeNode& node);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODE_PIPELINE_H_