[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
|
|
#ifndef TEST_CCTEST_INTERPRETER_BYTECODE_EXPECTATIONS_PRINTER_H_
|
|
|
|
|
#define TEST_CCTEST_INTERPRETER_BYTECODE_EXPECTATIONS_PRINTER_H_
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <string>
|
2016-02-19 12:36:26 +00:00
|
|
|
#include <vector>
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
|
|
|
|
|
#include "src/interpreter/bytecodes.h"
|
|
|
|
|
#include "src/objects.h"
|
|
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
|
|
|
|
|
|
class Isolate;
|
|
|
|
|
|
|
|
|
|
namespace internal {
|
2016-06-28 05:51:09 +00:00
|
|
|
|
2017-10-13 13:24:26 +00:00
|
|
|
class BytecodeArray;
|
2016-06-28 05:51:09 +00:00
|
|
|
class SourcePositionTableIterator;
|
|
|
|
|
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
namespace interpreter {
|
|
|
|
|
|
|
|
|
|
class BytecodeArrayIterator;
|
|
|
|
|
|
|
|
|
|
class BytecodeExpectationsPrinter final {
|
|
|
|
|
public:
|
2016-09-06 16:10:19 +00:00
|
|
|
explicit BytecodeExpectationsPrinter(v8::Isolate* i)
|
2016-02-19 12:36:26 +00:00
|
|
|
: isolate_(i),
|
2016-10-04 18:42:13 +00:00
|
|
|
module_(false),
|
2016-02-19 12:36:26 +00:00
|
|
|
wrap_(true),
|
2016-02-25 12:07:07 +00:00
|
|
|
top_level_(false),
|
2018-08-07 13:14:23 +00:00
|
|
|
print_callee_(false),
|
2018-08-10 12:41:06 +00:00
|
|
|
oneshot_opt_(false),
|
2016-02-19 12:36:26 +00:00
|
|
|
test_function_name_(kDefaultTopFunctionName) {}
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
|
|
|
|
|
void PrintExpectation(std::ostream& stream, // NOLINT
|
|
|
|
|
const std::string& snippet) const;
|
|
|
|
|
|
2016-10-04 18:42:13 +00:00
|
|
|
void set_module(bool module) { module_ = module; }
|
|
|
|
|
bool module() const { return module_; }
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
void set_wrap(bool wrap) { wrap_ = wrap; }
|
|
|
|
|
bool wrap() const { return wrap_; }
|
|
|
|
|
|
|
|
|
|
void set_top_level(bool top_level) { top_level_ = top_level; }
|
|
|
|
|
bool top_level() const { return top_level_; }
|
|
|
|
|
|
2018-08-07 13:14:23 +00:00
|
|
|
void set_print_callee(bool print_callee) { print_callee_ = print_callee; }
|
|
|
|
|
bool print_callee() { return print_callee_; }
|
|
|
|
|
|
|
|
|
|
void set_oneshot_opt(bool oneshot_opt) { oneshot_opt_ = oneshot_opt; }
|
|
|
|
|
bool oneshot_opt() { return oneshot_opt_; }
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
void set_test_function_name(const std::string& test_function_name) {
|
|
|
|
|
test_function_name_ = test_function_name;
|
|
|
|
|
}
|
|
|
|
|
std::string test_function_name() const { return test_function_name_; }
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
void PrintEscapedString(std::ostream& stream, // NOLINT
|
|
|
|
|
const std::string& string) const;
|
|
|
|
|
void PrintBytecodeOperand(std::ostream& stream, // NOLINT
|
2016-05-11 12:21:56 +00:00
|
|
|
const BytecodeArrayIterator& bytecode_iterator,
|
2016-02-19 12:36:26 +00:00
|
|
|
const Bytecode& bytecode, int op_index,
|
|
|
|
|
int parameter_count) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
void PrintBytecode(std::ostream& stream, // NOLINT
|
2016-05-11 12:21:56 +00:00
|
|
|
const BytecodeArrayIterator& bytecode_iterator,
|
2016-02-19 12:36:26 +00:00
|
|
|
int parameter_count) const;
|
2016-05-11 12:21:56 +00:00
|
|
|
void PrintSourcePosition(std::ostream& stream, // NOLINT
|
|
|
|
|
SourcePositionTableIterator& source_iterator,
|
|
|
|
|
int bytecode_offset) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
void PrintV8String(std::ostream& stream, // NOLINT
|
2018-11-27 00:48:42 +00:00
|
|
|
i::String string) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
void PrintConstant(std::ostream& stream, // NOLINT
|
|
|
|
|
i::Handle<i::Object> constant) const;
|
|
|
|
|
void PrintFrameSize(std::ostream& stream, // NOLINT
|
|
|
|
|
i::Handle<i::BytecodeArray> bytecode_array) const;
|
|
|
|
|
void PrintBytecodeSequence(std::ostream& stream, // NOLINT
|
|
|
|
|
i::Handle<i::BytecodeArray> bytecode_array) const;
|
|
|
|
|
void PrintConstantPool(std::ostream& stream, // NOLINT
|
2018-11-25 02:24:43 +00:00
|
|
|
i::FixedArray constant_pool) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
void PrintCodeSnippet(std::ostream& stream, // NOLINT
|
|
|
|
|
const std::string& body) const;
|
|
|
|
|
void PrintBytecodeArray(std::ostream& stream, // NOLINT
|
|
|
|
|
i::Handle<i::BytecodeArray> bytecode_array) const;
|
2016-02-19 12:36:26 +00:00
|
|
|
void PrintHandlers(std::ostream& stream, // NOLINT
|
|
|
|
|
i::Handle<i::BytecodeArray> bytecode_array) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
|
|
|
|
|
v8::Local<v8::String> V8StringFromUTF8(const char* data) const;
|
|
|
|
|
std::string WrapCodeInFunction(const char* function_name,
|
|
|
|
|
const std::string& function_body) const;
|
|
|
|
|
|
2016-10-04 18:42:13 +00:00
|
|
|
v8::Local<v8::Script> CompileScript(const char* program) const;
|
|
|
|
|
v8::Local<v8::Module> CompileModule(const char* program) const;
|
2016-02-19 12:36:26 +00:00
|
|
|
void Run(v8::Local<v8::Script> script) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
i::Handle<i::BytecodeArray> GetBytecodeArrayForGlobal(
|
|
|
|
|
const char* global_name) const;
|
2016-10-04 18:42:13 +00:00
|
|
|
i::Handle<v8::internal::BytecodeArray> GetBytecodeArrayForModule(
|
|
|
|
|
v8::Local<v8::Module> module) const;
|
2016-02-19 12:36:26 +00:00
|
|
|
i::Handle<v8::internal::BytecodeArray> GetBytecodeArrayForScript(
|
|
|
|
|
v8::Local<v8::Script> script) const;
|
2018-08-07 13:14:23 +00:00
|
|
|
i::Handle<i::BytecodeArray> GetBytecodeArrayOfCallee(
|
|
|
|
|
const char* source_code) const;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
|
|
|
|
|
i::Isolate* i_isolate() const {
|
|
|
|
|
return reinterpret_cast<i::Isolate*>(isolate_);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
v8::Isolate* isolate_;
|
2016-10-04 18:42:13 +00:00
|
|
|
bool module_;
|
2016-02-19 12:36:26 +00:00
|
|
|
bool wrap_;
|
|
|
|
|
bool top_level_;
|
2018-08-07 13:14:23 +00:00
|
|
|
bool print_callee_;
|
|
|
|
|
bool oneshot_opt_;
|
2016-02-19 12:36:26 +00:00
|
|
|
std::string test_function_name_;
|
|
|
|
|
|
|
|
|
|
static const char* const kDefaultTopFunctionName;
|
2016-05-11 12:21:56 +00:00
|
|
|
static const char* const kIndent;
|
[Interpreter] Change the output format of generate-bytecode-expectations.
Now the tool produces a far more readable output format, which bears a
lot of resemblance to YAML. In fact, the output should be machine
parseable as such, one document per testcase. However, the output format
may be subject to changes in future, so don't rely on this property.
In general, the output format has been optimized for producing a meaningful
textual diff, while keeping a decent readability as well. Therefore, not
everything is as compact as it could be, e.g. for an empty const pool we get:
constant pool: [
]
instead of:
constant pool: []
Also, trailing commas are always inserted in lists.
Additionally, now the tool accepts its output format as input. When
operating in this mode, all the snippets are extracted, processed and
the output is then emitted as usual. If nothing has changed, the output
should match the input. This is very useful for catching bugs in the
bytecode generation by running a textual diff against a known-good file.
The core (namely bytecode-expectations.cc) has been extracted from the
original cc file, which provides the utility as usual. The definitions
in the matching header of the library have been moved into the
v8::internal::interpreter namespace.
The library exposes a class ExpectationPrinter, with a method
PrintExpectation, which takes a test snippet as input, and writes the
formatted expectation to the supplied stream. One might then use a
std::stringstream to retrieve the results as a string and run it through
a diff utility.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1688383003
Cr-Commit-Position: refs/heads/master@{#33997}
2016-02-15 15:20:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} // namespace interpreter
|
|
|
|
|
} // namespace internal
|
|
|
|
|
} // namespace v8
|
|
|
|
|
|
|
|
|
|
#endif // TEST_CCTEST_INTERPRETER_BYTECODE_EXPECTATIONS_PRINTER_H_
|
