[Interpreter] generate-bytecode-expectations improvements.

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/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 {
 
+// static
+const char* const BytecodeExpectationsPrinter::kDefaultTopFunctionName =
+    "__genbckexp_wrapper__";
+
 v8::Local<v8::String> BytecodeExpectationsPrinter::V8StringFromUTF8(
     const char* data) const {
   return v8::String::NewFromUtf8(isolate_, data, v8::NewStringType::kNormal)
       .ToLocalChecked();
 }
 
 std::string BytecodeExpectationsPrinter::WrapCodeInFunction(
     const char* function_name, const std::string& function_body) const {
   std::ostringstream program_stream;
   program_stream << "function " << function_name << "() {" << function_body
                  << "}\n"
                  << function_name << "();";
 
   return program_stream.str();
 }
 
-v8::Local<v8::Value> BytecodeExpectationsPrinter::CompileAndRun(
+v8::Local<v8::Script> BytecodeExpectationsPrinter::Compile(
     const char* program) const {
   v8::Local<v8::String> source = V8StringFromUTF8(program);
-  v8::Local<v8::Script> script =
-      v8::Script::Compile(isolate_->GetCurrentContext(), source)
-          .ToLocalChecked();
+  return v8::Script::Compile(isolate_->GetCurrentContext(), source)
+      .ToLocalChecked();
+}
 
+void BytecodeExpectationsPrinter::Run(v8::Local<v8::Script> script) const {
   v8::Local<v8::Value> result;
   CHECK(script->Run(isolate_->GetCurrentContext()).ToLocal(&result));
-
-  return result;
+  (void)result;

[rmcilroy, 2016/02/17 15:24:08]

Just remove result variable and instead call:

CHECK(!script->Run(isolate_->GetCurrentContext().IsEmpty())

[Stefano Sanfilippo, 2016/02/17 16:40:49]

Done.

 }
 
 i::Handle<v8::internal::BytecodeArray>
 BytecodeExpectationsPrinter::GetBytecodeArrayForGlobal(
     const char* global_name) const {
   const v8::Local<v8::Context>& context = isolate_->GetCurrentContext();
   v8::Local<v8::String> v8_global_name = V8StringFromUTF8(global_name);
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       context->Global()->Get(context, v8_global_name).ToLocalChecked());
   i::Handle<i::JSFunction> js_function =
@@ skipping 17 matching lines @@
         break;
       default:
         stream << c;
         break;
     }
   }
 }
 
 void BytecodeExpectationsPrinter::PrintBytecodeOperand(
     std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
-    const Bytecode& bytecode, int op_index) const {
+    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";
       break;
     case OperandSize::kShort:
       size_tag = "16";
       break;
     default:
       UNREACHABLE();
       return;
   }
 
   if (Bytecodes::IsRegisterOperandType(op_type)) {
     Register register_value = bytecode_iter.GetRegisterOperand(op_index);
     stream << 'R';
     if (op_size != OperandSize::kByte) stream << size_tag;
-    stream << '(' << register_value.index() << ')';
+    if (register_value.is_new_target()) {
+      stream << "(new_target)";
+    } else if (register_value.is_current_context()) {
+      stream << "(context)";
+    } else if (register_value.is_function_closure()) {
+      stream << "(closure)";
+    } else if (register_value.is_parameter()) {
+      int parameter_index = register_value.ToParameterIndex(parameter_count);
+      if (parameter_index == 0) {
+        stream << "(this)";
+      } else {
+        stream << "(arg" << (parameter_index - 1) << ')';
+      }
+    } else {
+      stream << '(' << register_value.index() << ')';
+    }
   } else {
     stream << 'U' << size_tag << '(';
 
     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();
     }
 
     stream << ')';
   }
 }
 
 void BytecodeExpectationsPrinter::PrintBytecode(
-    std::ostream& stream, const BytecodeArrayIterator& bytecode_iter) const {
+    std::ostream& stream, const BytecodeArrayIterator& bytecode_iter,
+    int parameter_count) const {
   Bytecode bytecode = bytecode_iter.current_bytecode();
 
   stream << "B(" << Bytecodes::ToString(bytecode) << ')';
 
   int operands_count = Bytecodes::NumberOfOperands(bytecode);
   for (int op_index = 0; op_index < operands_count; ++op_index) {
     stream << ", ";
-    PrintBytecodeOperand(stream, bytecode_iter, bytecode, op_index);
+    PrintBytecodeOperand(stream, bytecode_iter, bytecode, op_index,
+                         parameter_count);
   }
 }
 
 void BytecodeExpectationsPrinter::PrintV8String(std::ostream& stream,
                                                 i::String* string) const {
   stream << '"';
   for (int i = 0, length = string->length(); i < length; ++i) {
     stream << i::AsEscapedUC16ForJSON(string->Get(i));
   }
   stream << '"';
@@ skipping 43 matching lines @@
   if (frame_size > 0) stream << "  # in multiples of sizeof(void*)";
   stream << "\nparameter count: " << bytecode_array->parameter_count() << '\n';
 }
 
 void BytecodeExpectationsPrinter::PrintBytecodeSequence(
     std::ostream& stream, i::Handle<i::BytecodeArray> bytecode_array) const {
   stream << "bytecodes: [\n";
   BytecodeArrayIterator bytecode_iter(bytecode_array);
   for (; !bytecode_iter.done(); bytecode_iter.Advance()) {
     stream << "  ";
-    PrintBytecode(stream, bytecode_iter);
+    PrintBytecode(stream, bytecode_iter, bytecode_array->parameter_count());
     stream << ",\n";
   }
   stream << "]\n";
 }
 
 void BytecodeExpectationsPrinter::PrintConstantPool(
     std::ostream& stream, i::FixedArray* constant_pool) const {
   stream << "constant pool: [\n";
   int num_constants = constant_pool->length();
   if (num_constants > 0) {
@@ skipping 12 matching lines @@
   std::stringstream body_stream(body);
   std::string body_line;
   while (std::getline(body_stream, body_line)) {
     stream << "  ";
     PrintEscapedString(stream, body_line);
     stream << '\n';
   }
   stream << "\"\n";
 }
 
+void BytecodeExpectationsPrinter::PrintHandlers(
+    std::ostream& stream, i::Handle<i::BytecodeArray> bytecode_array) const {
+  stream << "handlers: [\n";
+  HandlerTable* table = HandlerTable::cast(bytecode_array->handler_table());
+  for (int i = 0, num_entries = table->NumberOfRangeEntries(); i < num_entries;
+       ++i) {
+    stream << "  [" << table->GetRangeStart(i) << ", " << table->GetRangeEnd(i)
+           << ", " << table->GetRangeHandler(i) << "],\n";
+  }
+  stream << "]\n";
+}
+
 void BytecodeExpectationsPrinter::PrintBytecodeArray(
-    std::ostream& stream, const std::string& body,
-    i::Handle<i::BytecodeArray> bytecode_array) const {
-  stream << "---\n";
-  PrintCodeSnippet(stream, body);
+    std::ostream& stream, i::Handle<i::BytecodeArray> bytecode_array) const {
   PrintFrameSize(stream, bytecode_array);
   PrintBytecodeSequence(stream, bytecode_array);
   PrintConstantPool(stream, bytecode_array->constant_pool());
-
-  // TODO(ssanfilippo) print handlers.
-  i::HandlerTable* handlers =
-      i::HandlerTable::cast(bytecode_array->handler_table());
-  CHECK_EQ(handlers->NumberOfRangeEntries(), 0);
+  PrintHandlers(stream, bytecode_array);
 }
 
 void BytecodeExpectationsPrinter::PrintExpectation(
     std::ostream& stream, const std::string& snippet) const {
-  const char* wrapper_function_name = "__genbckexp_wrapper__";
+  std::string source_code =
+      wrap_ ? WrapCodeInFunction(top_function_name_.c_str(), snippet) : snippet;
 
-  std::string source_code = WrapCodeInFunction(wrapper_function_name, snippet);
-  CompileAndRun(source_code.c_str());
+  v8::Local<v8::Script> script = Compile(source_code.c_str());
+
+  if (execute_) Run(script);
 
   i::Handle<i::BytecodeArray> bytecode_array =
-      GetBytecodeArrayForGlobal(wrapper_function_name);
+      GetBytecodeArrayForGlobal(top_function_name_.c_str());
 
-  PrintBytecodeArray(stream, snippet, bytecode_array);
+  stream << "---\n";
+  PrintCodeSnippet(stream, snippet);
+  PrintBytecodeArray(stream, bytecode_array);
   stream << '\n';
 }
 
+namespace {
+
+const char* ConstantPoolTypeToString(
+    BytecodeExpectationsPrinter::ConstantPoolType type) {
+  switch (type) {
+    case BytecodeExpectationsPrinter::ConstantPoolType::kDouble:
+      return "double";
+    case BytecodeExpectationsPrinter::ConstantPoolType::kInteger:
+      return "integer";
+    case BytecodeExpectationsPrinter::ConstantPoolType::kMixed:
+      return "mixed";
+    case BytecodeExpectationsPrinter::ConstantPoolType::kString:
+      return "string";
+    default:
+      UNREACHABLE();
+      return nullptr;
+  }
+}
+
+const char* BooleanToString(bool value) { return value ? "yes" : "no"; }
+
+}  // namespace
+
+void BytecodeExpectationsPrinter::PrintOptionsHeader(std::ostream& stream) {
+  stream << "---"
+            "\npool type: "
+         << ConstantPoolTypeToString(const_pool_type_)
+         << "\nexecute: " << BooleanToString(execute_)
+         << "\nwrap: " << BooleanToString(wrap_);
+
+  if (top_function_name_ != kDefaultTopFunctionName) {
+    stream << "\nwrapper name: " << top_function_name_;
+  }
+
+  stream << "\n\n";
+}
+
+void BytecodeExpectationsPrinter::PrintExpectationsArray(
+    std::ostream& stream, const std::vector<std::string>& snippet_list) {
+  stream << "#\n# Autogenerated by generate-bytecode-expectations\n#\n\n";

[rmcilroy, 2016/02/17 15:24:08]

I meant to move this into the generate-bytecode-expectations. You should also do
the printing of the options in generate-bytecode-expectations (since that is
where you do the parsing of those options).

[Stefano Sanfilippo, 2016/02/17 16:40:49]

The issue is that if we don't have this code inside the library, the tests will
not be able to exactly reproduce the same format of
generate-bytecode-expecations.

[rmcilroy, 2016/02/17 17:06:36]

The tests should just ignore the headers and only diff the snippets I think.

[Stefano Sanfilippo, 2016/02/17 17:31:18]

OK, then I'll make the test harness skip the golden file header.

+  PrintOptionsHeader(stream);
+  for (const std::string& snippet : snippet_list) {
+    PrintExpectation(stream, snippet);
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8