[Interpreter] Templatize AccumulatorUsage and OperandType for bytecode creation.

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);
   }
 
+  template <Bytecode bytecode>
+  INLINE(static BytecodeNode Create(
+      BytecodeSourceInfo source_info = BytecodeSourceInfo())) {
+    return BytecodeNode(bytecode, 0, OperandScale::kSingle, source_info);
+  }
+
+  template <Bytecode bytecode, OperandType operand0_type>
+  INLINE(static BytecodeNode Create(
+      uint32_t operand0,
+      BytecodeSourceInfo source_info = BytecodeSourceInfo())) {
+    OperandScale scale = OperandScale::kSingle;
+    scale = std::max(scale, ScaleForOperand<operand0_type>(operand0));
+    return BytecodeNode(bytecode, 1, scale, source_info, operand0);
+  }
+
+  template <Bytecode bytecode, OperandType operand0_type,
+            OperandType operand1_type>
+  INLINE(static BytecodeNode Create(
+      uint32_t operand0, uint32_t operand1,
+      BytecodeSourceInfo source_info = BytecodeSourceInfo())) {
+    OperandScale scale = OperandScale::kSingle;
+    scale = std::max(scale, ScaleForOperand<operand0_type>(operand0));
+    scale = std::max(scale, ScaleForOperand<operand1_type>(operand1));
+    return BytecodeNode(bytecode, 2, scale, source_info, operand0, operand1);
+  }
+
+  template <Bytecode bytecode, OperandType operand0_type,
+            OperandType operand1_type, OperandType operand2_type>
+  INLINE(static BytecodeNode Create(
+      uint32_t operand0, uint32_t operand1, uint32_t operand2,
+      BytecodeSourceInfo source_info = BytecodeSourceInfo())) {
+    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));
+    return BytecodeNode(bytecode, 3, scale, source_info, operand0, operand1,
+                        operand2);
+  }
+
+  template <Bytecode bytecode, OperandType operand0_type,
+            OperandType operand1_type, OperandType operand2_type,
+            OperandType operand3_type>
+  INLINE(static BytecodeNode Create(
+      uint32_t operand0, uint32_t operand1, uint32_t operand2,
+      uint32_t operand3,
+      BytecodeSourceInfo source_info = BytecodeSourceInfo())) {
+    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);
+  }
+
   // Replace the bytecode of this node with |bytecode| and keep the operands.
   void replace_bytecode(Bytecode bytecode) {
     DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode_),
               Bytecodes::NumberOfOperands(bytecode));
     bytecode_ = bytecode;
   }
 
-  void set_bytecode(Bytecode bytecode) {
-    DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 0);
-    bytecode_ = bytecode;
-    operand_count_ = 0;
-    operand_scale_ = OperandScale::kSingle;
-  }
-
-  void set_bytecode(Bytecode bytecode, uint32_t operand0) {
-    DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 1);
-    bytecode_ = bytecode;
-    operand_count_ = 1;
-    operand_scale_ = OperandScale::kSingle;
-    SetOperand(0, operand0);
-  }
-
-  void set_bytecode(Bytecode bytecode, uint32_t operand0, uint32_t operand1) {
-    DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 2);
-    bytecode_ = bytecode;
-    operand_count_ = 2;
-    operand_scale_ = OperandScale::kSingle;
-    SetOperand(0, operand0);
-    SetOperand(1, operand1);
-  }
-
-  void set_bytecode(Bytecode bytecode, uint32_t operand0, uint32_t operand1,
-                    uint32_t operand2) {
-    DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 3);
-    bytecode_ = bytecode;
-    operand_count_ = 3;
-    operand_scale_ = OperandScale::kSingle;
-    SetOperand(0, operand0);
-    SetOperand(1, operand1);
-    SetOperand(2, operand2);
-  }
+  void update_operand0(uint32_t operand0) { SetOperand(0, operand0); }
 
   // Print to stream |os|.
   void Print(std::ostream& os) const;
 
   // Transform to a node representing |new_bytecode| which has one
   // operand more than the current bytecode.
   void Transform(Bytecode new_bytecode, uint32_t extra_operand) {
     DCHECK_EQ(Bytecodes::NumberOfOperands(new_bytecode),
               Bytecodes::NumberOfOperands(bytecode()) + 1);
     DCHECK(Bytecodes::NumberOfOperands(bytecode()) < 1 ||
@@ skipping 25 matching lines @@
 
   const BytecodeSourceInfo& source_info() const { return source_info_; }
   void set_source_info(BytecodeSourceInfo source_info) {
     source_info_ = source_info;
   }
 
   bool operator==(const BytecodeNode& other) const;
   bool operator!=(const BytecodeNode& other) const { return !(*this == other); }
 
  private:
+  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))
+      : 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;
+  }
+
+  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;
+    }
+  }
+
   INLINE(void UpdateScaleForOperand(int operand_index, uint32_t operand)) {
     if (Bytecodes::OperandIsScalableSignedByte(bytecode(), operand_index)) {
       operand_scale_ =
           std::max(operand_scale_, Bytecodes::ScaleForSignedOperand(operand));
     } else if (Bytecodes::OperandIsScalableUnsignedByte(bytecode(),
                                                         operand_index)) {
       operand_scale_ =
           std::max(operand_scale_, Bytecodes::ScaleForUnsignedOperand(operand));
     }
   }
 
   INLINE(void SetOperand(int operand_index, uint32_t operand)) {
     operands_[operand_index] = operand;
     UpdateScaleForOperand(operand_index, operand);

[Leszek Swirski, 2016/12/05 10:57:42]

Should we now no longer do this, but instead DCHECK that the current scale is
sufficient for the operand?

[rmcilroy, 2016/12/09 09:21:05]

We still need this for the non-templated constructors. Since we are constructing
the bytecode we don't know the scale yet, and so SetOperand needs to update it
as needed during construction.

[Leszek Swirski, 2016/12/12 14:55:41]

Ah, ok, I thought you were getting rid of the non-templated constructors. Sounds
good.

[rmcilroy, 2016/12/15 07:52:55]

Yeah I am hoping to eventually get rid of them, but we still need them for the
peephole optimizer for now.

   }
 
   Bytecode bytecode_;
   uint32_t operands_[Bytecodes::kMaxOperands];
   int operand_count_;
   OperandScale operand_scale_;
   BytecodeSourceInfo source_info_;
 };
 
 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_