[Interpreter] Add option to trace bytecode execution.

src/interpreter/bytecodes.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/bytecodes.h"
 
 #include "src/frames.h"
 #include "src/interpreter/bytecode-traits.h"
 
 namespace v8 {
@@ skipping 362 matching lines @@
       case interpreter::OperandType::kImm8:
         os << "#" << static_cast<int>(static_cast<int8_t>(*operand_start));
         break;
       case interpreter::OperandType::kMaybeReg8:
       case interpreter::OperandType::kMaybeReg16:
       case interpreter::OperandType::kReg8:
       case interpreter::OperandType::kReg16:
       case interpreter::OperandType::kRegOut8:
       case interpreter::OperandType::kRegOut16: {
         Register reg = DecodeRegister(operand_start, op_type);
-        if (reg.is_current_context()) {
-          os << "<context>";
-        } else if (reg.is_function_closure()) {
-          os << "<closure>";
-        } else if (reg.is_new_target()) {
-          os << "<new.target>";
-        } else if (reg.is_parameter()) {
-          int parameter_index = reg.ToParameterIndex(parameter_count);
-          if (parameter_index == 0) {
-            os << "<this>";
-          } else {
-            os << "a" << parameter_index - 1;
-          }
-        } else {
-          os << "r" << reg.index();
-        }
+        os << reg.ToString(parameter_count);
         break;
       }
       case interpreter::OperandType::kRegOutTriple8:
       case interpreter::OperandType::kRegOutTriple16:
         range += 1;
       case interpreter::OperandType::kRegOutPair8:
       case interpreter::OperandType::kRegOutPair16:
       case interpreter::OperandType::kRegPair8:
       case interpreter::OperandType::kRegPair16: {
         range += 1;
-        Register reg = DecodeRegister(operand_start, op_type);
-        if (reg.is_parameter()) {
-          int parameter_index = reg.ToParameterIndex(parameter_count);
-          DCHECK_GT(parameter_index, 0);
-          os << "a" << parameter_index - range << "-" << parameter_index;
-        } else {
-          os << "r" << reg.index() << "-" << reg.index() + range;
-        }
+        Register first_reg = DecodeRegister(operand_start, op_type);
+        Register last_reg = Register(first_reg.index() + range);
+        os << first_reg.ToString(parameter_count) << "-"
+           << last_reg.ToString(parameter_count);
         break;
       }
       case interpreter::OperandType::kNone:
         UNREACHABLE();
         break;
     }
     if (i != number_of_operands - 1) {
       os << ", ";
     }
   }
   return os;
 }
 
-
 std::ostream& operator<<(std::ostream& os, const Bytecode& bytecode) {
   return os << Bytecodes::ToString(bytecode);
 }
 
 
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type) {
   return os << Bytecodes::OperandTypeToString(operand_type);
 }
 
 
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_size) {
   return os << Bytecodes::OperandSizeToString(operand_size);
 }
 
-
 static const int kLastParamRegisterIndex =
     -InterpreterFrameConstants::kLastParamFromRegisterPointer / kPointerSize;
 static const int kFunctionClosureRegisterIndex =
     -InterpreterFrameConstants::kFunctionFromRegisterPointer / kPointerSize;
 static const int kCurrentContextRegisterIndex =
     -InterpreterFrameConstants::kContextFromRegisterPointer / kPointerSize;
 static const int kNewTargetRegisterIndex =
     -InterpreterFrameConstants::kNewTargetFromRegisterPointer / kPointerSize;
 
 // The register space is a signed 16-bit space. Register operands
@@ skipping 106 matching lines @@
   }
   if (reg4.is_valid() && reg3.index() + 1 != reg4.index()) {
     return false;
   }
   if (reg5.is_valid() && reg4.index() + 1 != reg5.index()) {
     return false;
   }
   return true;
 }
 
+std::string Register::ToString(int parameter_count) {
+  if (is_current_context()) {
+    return std::string("<context>");
+  } else if (is_function_closure()) {
+    return std::string("<closure>");
+  } else if (is_new_target()) {
+    return std::string("<new.target>");
+  } else if (is_parameter()) {
+    int parameter_index = ToParameterIndex(parameter_count);
+    if (parameter_index == 0) {
+      return std::string("<this>");
+    } else {
+      std::ostringstream s;
+      s << "a" << parameter_index - 1;
+      return s.str();
+    }
+  } else {
+    std::ostringstream s;
+    s << "r" << index();
+    return s.str();
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8