[Interpreter] Textual representation for runtime function IDs.

test/cctest/interpreter/bytecode-expectations-printer.cc

 // Copyright 2016 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 "test/cctest/interpreter/bytecode-expectations-printer.h"
 
 #include <iostream>
 #include <vector>
 
 #include "include/libplatform/libplatform.h"
 #include "include/v8.h"
 
 #include "src/base/logging.h"
 #include "src/base/smart-pointers.h"
 #include "src/compiler.h"
+#include "src/runtime/runtime.h"
 
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/interpreter/interpreter.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
 
@@ skipping 61 matching lines @@
       case '\\':
         stream << "\\\\";
         break;
       default:
         stream << c;
         break;
     }
   }
 }
 
+namespace {
+i::Runtime::FunctionId IndexToFunctionId(int index) {
+  return static_cast<i::Runtime::FunctionId>(index);
+}
+}  // namespace
+
 void BytecodeExpectationsPrinter::PrintBytecodeOperand(
     std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
     const Bytecode& bytecode, int op_index, int parameter_count) const {
   OperandType op_type = Bytecodes::GetOperandType(bytecode, op_index);
   OperandSize op_size = Bytecodes::GetOperandSize(bytecode, op_index);
 
   const char* size_tag;
   switch (op_size) {
     case OperandSize::kByte:
       size_tag = "8";
@@ skipping 22 matching lines @@
         stream << "(this)";
       } else {
         stream << "(arg" << (parameter_index - 1) << ')';
       }
     } else {
       stream << '(' << register_value.index() << ')';
     }
   } else {
     stream << 'U' << size_tag << '(';
 
-    if (Bytecodes::IsImmediateOperandType(op_type)) {
+    if (op_index == 0 && Bytecodes::IsCallRuntime(bytecode)) {
+      DCHECK_EQ(op_type, OperandType::kIdx16);
+      int operand = bytecode_iter.GetIndexOperand(op_index);
+      stream << "Runtime::k"
+             << i::Runtime::FunctionForId(IndexToFunctionId(operand))->name;
+    } else if (Bytecodes::IsImmediateOperandType(op_type)) {
       // We need a cast, otherwise the result is printed as char.
       stream << static_cast<int>(bytecode_iter.GetImmediateOperand(op_index));
     } else if (Bytecodes::IsRegisterCountOperandType(op_type)) {
       stream << bytecode_iter.GetRegisterCountOperand(op_index);
     } else if (Bytecodes::IsIndexOperandType(op_type)) {
       stream << bytecode_iter.GetIndexOperand(op_index);
     } else {
       UNREACHABLE();
     }
 
@@ skipping 142 matching lines @@
 
   stream << "---\n";
   PrintCodeSnippet(stream, snippet);
   PrintBytecodeArray(stream, bytecode_array);
   stream << '\n';
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8