[interpreter] Introduce fused bytecodes for common sequences.

src/interpreter/bytecode-pipeline.cc

 // 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.
 
 #include "src/interpreter/bytecode-pipeline.h"
 
 #include <iomanip>
 #include "src/interpreter/source-position-table.h"
 
 namespace v8 {
@@ skipping 72 matching lines @@
 }
 
 void BytecodeNode::set_bytecode(Bytecode bytecode, uint32_t operand0,
                                 OperandScale operand_scale) {
   DCHECK_EQ(Bytecodes::NumberOfOperands(bytecode), 1);
   bytecode_ = bytecode;
   operands_[0] = operand0;
   operand_scale_ = operand_scale;
 }
 
-size_t BytecodeNode::Size() const {
-  size_t size = Bytecodes::Size(bytecode_, operand_scale_);
-  if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale_)) {
-    size += 1;
-  }
-  return size;
+void BytecodeNode::Clone(const BytecodeNode* const other) {
+  memcpy(this, other, sizeof(*other));
 }
 
 void BytecodeNode::Print(std::ostream& os) const {
 #ifdef DEBUG
   std::ios saved_state(nullptr);
   saved_state.copyfmt(os);
 
   os << Bytecodes::ToString(bytecode_);
   if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale_)) {
     Bytecode scale_prefix =
         Bytecodes::OperandScaleToPrefixBytecode(operand_scale_);
     os << '.' << Bytecodes::ToString(scale_prefix);
   }
 
   for (int i = 0; i < operand_count(); ++i) {
     os << ' ' << std::setw(8) << std::setfill('0') << std::hex << operands_[i];
   }
   os.copyfmt(saved_state);
 
   if (source_info_.is_valid()) {
-    os << source_info_;
+    os << ' ' << source_info_;
   }
   os << '\n';
 #else
   os << static_cast<const void*>(this);
 #endif  // DEBUG
 }
 
-void BytecodeNode::Clone(const BytecodeNode* const other) {
-  memcpy(this, other, sizeof(*other));
+size_t BytecodeNode::Size() const {
+  size_t size = Bytecodes::Size(bytecode_, operand_scale_);
+  if (Bytecodes::OperandScaleRequiresPrefixBytecode(operand_scale_)) {
+    size += 1;
+  }
+  return size;
+}
+
+void BytecodeNode::Transform(Bytecode new_bytecode, uint32_t extra_operand,
+                             OperandScale extra_operand_scale) {
+  DCHECK_EQ(Bytecodes::NumberOfOperands(new_bytecode),
+            Bytecodes::NumberOfOperands(bytecode()) + 1);
+  DCHECK(Bytecodes::NumberOfOperands(bytecode()) < 1 ||
+         Bytecodes::GetOperandType(new_bytecode, 0) ==
+             Bytecodes::GetOperandType(bytecode(), 0));
+  DCHECK(Bytecodes::NumberOfOperands(bytecode()) < 2 ||
+         Bytecodes::GetOperandType(new_bytecode, 1) ==
+             Bytecodes::GetOperandType(bytecode(), 1));
+  DCHECK(Bytecodes::NumberOfOperands(bytecode()) < 3 ||
+         Bytecodes::GetOperandType(new_bytecode, 2) ==
+             Bytecodes::GetOperandType(bytecode(), 2));
+  DCHECK(Bytecodes::NumberOfOperands(bytecode()) < 4);
+  operand_scale_ = std::max(extra_operand_scale, operand_scale());
+  operands_[operand_count()] = extra_operand;
+  bytecode_ = new_bytecode;
 }
 
 bool BytecodeNode::operator==(const BytecodeNode& other) const {
   if (this == &other) {
     return true;
   } else if (this->bytecode() != other.bytecode() ||
              this->source_info() != other.source_info()) {
     return false;
   } else {
     for (int i = 0; i < this->operand_count(); ++i) {
@@ skipping 14 matching lines @@
   if (info.is_valid()) {
     char description = info.is_statement() ? 'S' : 'E';
     os << info.source_position() << ' ' << description << '>';
   }
   return os;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8