[interpreter] Teach --print-bytecode the names of runtime functions and intrinsics.

src/interpreter/bytecode-decoder.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-decoder.h"
 
 #include <iomanip>
 
-#include "src/utils.h"
+#include "src/interpreter/interpreter-intrinsics.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
 // static
 Register BytecodeDecoder::DecodeRegisterOperand(const uint8_t* operand_start,
                                                 OperandType operand_type,
                                                 OperandScale operand_scale) {
   DCHECK(Bytecodes::IsRegisterOperandType(operand_type));
@@ skipping 40 matching lines @@
     case OperandSize::kShort:
       return ReadUnalignedUInt16(operand_start);
     case OperandSize::kQuad:
       return ReadUnalignedUInt32(operand_start);
     case OperandSize::kNone:
       UNREACHABLE();
   }
   return 0;
 }
 
+namespace {
+const char* NameForIntrinsicId(uint32_t idx) {
+  switch (static_cast<IntrinsicsHelper::IntrinsicId>(idx)) {
+#define CASE(name, nargs, ressize)             \
+  case IntrinsicsHelper::IntrinsicId::k##name: \
+    return #name;
+    INTRINSICS_LIST(CASE)
+#undef CASE
+    default:
+      UNREACHABLE();
+      return nullptr;
+  }
+}
+
+const char* NameForRuntimeId(uint32_t idx) {
+  switch (idx) {
+#define CASE(name, nargs, ressize) \
+  case Runtime::k##name:           \
+    return #name;                  \
+  case Runtime::kInline##name:     \
+    return #name;
+    FOR_EACH_INTRINSIC(CASE)
+#undef CASE
+    default:
+      UNREACHABLE();
+      return nullptr;
+  }
+}
+}  // anonymous namespace
+
 // static
 std::ostream& BytecodeDecoder::Decode(std::ostream& os,
                                       const uint8_t* bytecode_start,
                                       int parameter_count) {
   Bytecode bytecode = Bytecodes::FromByte(bytecode_start[0]);
   int prefix_offset = 0;
   OperandScale operand_scale = OperandScale::kSingle;
   if (Bytecodes::IsPrefixScalingBytecode(bytecode)) {
     prefix_offset = 1;
     operand_scale = Bytecodes::PrefixBytecodeToOperandScale(bytecode);
@@ skipping 25 matching lines @@
   int number_of_operands = Bytecodes::NumberOfOperands(bytecode);
   for (int i = 0; i < number_of_operands; i++) {
     OperandType op_type = Bytecodes::GetOperandType(bytecode, i);
     int operand_offset =
         Bytecodes::GetOperandOffset(bytecode, i, operand_scale);
     const uint8_t* operand_start =
         &bytecode_start[prefix_offset + operand_offset];
     switch (op_type) {
       case interpreter::OperandType::kIdx:
       case interpreter::OperandType::kUImm:
-      case interpreter::OperandType::kRuntimeId:
-      case interpreter::OperandType::kIntrinsicId:
         os << "["
            << DecodeUnsignedOperand(operand_start, op_type, operand_scale)
            << "]";
         break;
+      case interpreter::OperandType::kIntrinsicId:
+        os << "[" << NameForIntrinsicId(DecodeUnsignedOperand(

[rmcilroy, 2017/02/23 13:47:13]

nit - could you just do NameForRuntimeId(IntrinsicHelper::ToRuntimeId(...)) and
avoid the need for the additional NameForIntrinsicId function?

[neis, 2017/02/23 14:02:55]

Done.

+                         operand_start, op_type, operand_scale))
+           << "]";
+        break;
+      case interpreter::OperandType::kRuntimeId:
+        os << "[" << NameForRuntimeId(DecodeUnsignedOperand(
+                         operand_start, op_type, operand_scale))
+           << "]";
+        break;
       case interpreter::OperandType::kImm:
         os << "[" << DecodeSignedOperand(operand_start, op_type, operand_scale)
            << "]";
         break;
       case interpreter::OperandType::kFlag8:
         os << "#"
            << DecodeUnsignedOperand(operand_start, op_type, operand_scale);
         break;
       case interpreter::OperandType::kReg:
       case interpreter::OperandType::kRegOut: {
@@ skipping 42 matching lines @@
     if (i != number_of_operands - 1) {
       os << ", ";
     }
   }
   return os;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8