2016-02-10 11:26:14 +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.
|
|
|
|
|
|
[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 <cstring>
|
2016-02-10 11:26:14 +00:00
|
|
|
#include <fstream>
|
2016-07-25 11:12:42 +00:00
|
|
|
#include <memory>
|
2016-02-26 12:04:03 +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 "test/cctest/interpreter/bytecode-expectations-printer.h"
|
2016-02-10 11:26:14 +00:00
|
|
|
|
|
|
|
|
#include "include/libplatform/libplatform.h"
|
|
|
|
|
#include "include/v8.h"
|
|
|
|
|
|
|
|
|
|
#include "src/base/logging.h"
|
|
|
|
|
#include "src/interpreter/interpreter.h"
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
#ifdef V8_OS_POSIX
|
|
|
|
|
#include <dirent.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
[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
|
|
|
using v8::internal::interpreter::BytecodeExpectationsPrinter;
|
2016-02-10 11:26:14 +00:00
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
#define REPORT_ERROR(MESSAGE) (((std::cerr << "ERROR: ") << MESSAGE) << '\n')
|
|
|
|
|
|
2016-02-10 11:26:14 +00:00
|
|
|
namespace {
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
#ifdef V8_OS_POSIX
|
|
|
|
|
const char* kGoldenFilesPath = "test/cctest/interpreter/bytecode_expectations/";
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
class ProgramOptions final {
|
[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
|
|
|
public:
|
|
|
|
|
static ProgramOptions FromCommandLine(int argc, char** argv);
|
|
|
|
|
|
|
|
|
|
ProgramOptions()
|
|
|
|
|
: parsing_failed_(false),
|
|
|
|
|
print_help_(false),
|
|
|
|
|
read_raw_js_snippet_(false),
|
|
|
|
|
read_from_stdin_(false),
|
2016-02-19 12:36:26 +00:00
|
|
|
rebaseline_(false),
|
|
|
|
|
wrap_(true),
|
2016-10-04 18:42:13 +00:00
|
|
|
module_(false),
|
2016-02-19 12:36:26 +00:00
|
|
|
top_level_(false),
|
2016-02-19 15:52:48 +00:00
|
|
|
do_expressions_(false),
|
2017-02-24 17:48:49 +00:00
|
|
|
async_iteration_(false),
|
2017-11-28 09:42:57 +00:00
|
|
|
public_fields_(false),
|
2017-12-21 17:58:28 +00:00
|
|
|
static_fields_(false),
|
2016-09-06 16:10:19 +00:00
|
|
|
verbose_(false) {}
|
[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
|
|
|
|
|
|
|
|
bool Validate() const;
|
2016-02-19 12:36:26 +00:00
|
|
|
void UpdateFromHeader(std::istream& stream); // NOLINT
|
|
|
|
|
void PrintHeader(std::ostream& stream) const; // NOLINT
|
[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
|
|
|
|
|
|
|
|
bool parsing_failed() const { return parsing_failed_; }
|
|
|
|
|
bool print_help() const { return print_help_; }
|
|
|
|
|
bool read_raw_js_snippet() const { return read_raw_js_snippet_; }
|
|
|
|
|
bool read_from_stdin() const { return read_from_stdin_; }
|
2016-02-19 12:36:26 +00:00
|
|
|
bool write_to_stdout() const {
|
|
|
|
|
return output_filename_.empty() && !rebaseline_;
|
|
|
|
|
}
|
|
|
|
|
bool rebaseline() const { return rebaseline_; }
|
|
|
|
|
bool wrap() const { return wrap_; }
|
2016-10-04 18:42:13 +00:00
|
|
|
bool module() const { return module_; }
|
2016-02-19 12:36:26 +00:00
|
|
|
bool top_level() const { return top_level_; }
|
2016-02-19 15:52:48 +00:00
|
|
|
bool do_expressions() const { return do_expressions_; }
|
2017-02-24 17:48:49 +00:00
|
|
|
bool async_iteration() const { return async_iteration_; }
|
2017-11-28 09:42:57 +00:00
|
|
|
bool public_fields() const { return public_fields_; }
|
2017-12-21 17:58:28 +00:00
|
|
|
bool static_fields() const { return static_fields_; }
|
2016-02-26 12:04:03 +00:00
|
|
|
bool verbose() const { return verbose_; }
|
2016-03-01 10:41:56 +00:00
|
|
|
bool suppress_runtime_errors() const { return rebaseline_ && !verbose_; }
|
2016-02-26 12:04:03 +00:00
|
|
|
std::vector<std::string> input_filenames() const { return input_filenames_; }
|
2016-02-19 12:36:26 +00:00
|
|
|
std::string output_filename() const { return output_filename_; }
|
|
|
|
|
std::string test_function_name() const { return test_function_name_; }
|
2016-02-10 11:26:14 +00:00
|
|
|
|
[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:
|
|
|
|
|
bool parsing_failed_;
|
|
|
|
|
bool print_help_;
|
|
|
|
|
bool read_raw_js_snippet_;
|
|
|
|
|
bool read_from_stdin_;
|
2016-02-19 12:36:26 +00:00
|
|
|
bool rebaseline_;
|
|
|
|
|
bool wrap_;
|
2016-10-04 18:42:13 +00:00
|
|
|
bool module_;
|
2016-02-19 12:36:26 +00:00
|
|
|
bool top_level_;
|
2016-02-19 15:52:48 +00:00
|
|
|
bool do_expressions_;
|
2017-02-24 17:48:49 +00:00
|
|
|
bool async_iteration_;
|
2017-11-28 09:42:57 +00:00
|
|
|
bool public_fields_;
|
2017-12-21 17:58:28 +00:00
|
|
|
bool static_fields_;
|
2016-02-26 12:04:03 +00:00
|
|
|
bool verbose_;
|
|
|
|
|
std::vector<std::string> input_filenames_;
|
2016-02-19 12:36:26 +00:00
|
|
|
std::string output_filename_;
|
|
|
|
|
std::string test_function_name_;
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
};
|
|
|
|
|
|
2016-02-10 11:26:14 +00:00
|
|
|
class V8InitializationScope final {
|
|
|
|
|
public:
|
|
|
|
|
explicit V8InitializationScope(const char* exec_path);
|
|
|
|
|
~V8InitializationScope();
|
|
|
|
|
|
|
|
|
|
v8::Platform* platform() const { return platform_.get(); }
|
|
|
|
|
v8::Isolate* isolate() const { return isolate_; }
|
|
|
|
|
|
|
|
|
|
private:
|
2016-07-25 11:12:42 +00:00
|
|
|
std::unique_ptr<v8::Platform> platform_;
|
|
|
|
|
std::unique_ptr<v8::ArrayBuffer::Allocator> allocator_;
|
2016-02-10 11:26:14 +00:00
|
|
|
v8::Isolate* isolate_;
|
|
|
|
|
|
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(V8InitializationScope);
|
|
|
|
|
};
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
bool ParseBoolean(const char* string) {
|
|
|
|
|
if (strcmp(string, "yes") == 0) {
|
|
|
|
|
return true;
|
|
|
|
|
} else if (strcmp(string, "no") == 0) {
|
|
|
|
|
return false;
|
|
|
|
|
} else {
|
|
|
|
|
UNREACHABLE();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* BooleanToString(bool value) { return value ? "yes" : "no"; }
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
#ifdef V8_OS_POSIX
|
|
|
|
|
|
|
|
|
|
bool StrEndsWith(const char* string, const char* suffix) {
|
|
|
|
|
int string_size = i::StrLength(string);
|
|
|
|
|
int suffix_size = i::StrLength(suffix);
|
|
|
|
|
if (string_size < suffix_size) return false;
|
|
|
|
|
|
|
|
|
|
return strcmp(string + (string_size - suffix_size), suffix) == 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool CollectGoldenFiles(std::vector<std::string>* golden_file_list,
|
|
|
|
|
const char* directory_path) {
|
|
|
|
|
DIR* directory = opendir(directory_path);
|
|
|
|
|
if (!directory) return false;
|
|
|
|
|
|
2016-09-30 11:05:17 +00:00
|
|
|
dirent* entry = readdir(directory);
|
|
|
|
|
while (entry) {
|
2016-02-26 12:04:03 +00:00
|
|
|
if (StrEndsWith(entry->d_name, ".golden")) {
|
|
|
|
|
std::string golden_filename(kGoldenFilesPath);
|
|
|
|
|
golden_filename += entry->d_name;
|
|
|
|
|
golden_file_list->push_back(golden_filename);
|
|
|
|
|
}
|
2016-09-30 11:05:17 +00:00
|
|
|
entry = readdir(directory);
|
2016-02-26 12:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
closedir(directory);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif // V8_OS_POSIX
|
|
|
|
|
|
[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
|
|
|
// static
|
|
|
|
|
ProgramOptions ProgramOptions::FromCommandLine(int argc, char** argv) {
|
|
|
|
|
ProgramOptions options;
|
|
|
|
|
|
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
|
|
|
if (strcmp(argv[i], "--help") == 0) {
|
|
|
|
|
options.print_help_ = true;
|
|
|
|
|
} else if (strcmp(argv[i], "--raw-js") == 0) {
|
|
|
|
|
options.read_raw_js_snippet_ = true;
|
|
|
|
|
} else if (strcmp(argv[i], "--stdin") == 0) {
|
|
|
|
|
options.read_from_stdin_ = true;
|
2016-02-19 12:36:26 +00:00
|
|
|
} else if (strcmp(argv[i], "--rebaseline") == 0) {
|
|
|
|
|
options.rebaseline_ = true;
|
|
|
|
|
} else if (strcmp(argv[i], "--no-wrap") == 0) {
|
|
|
|
|
options.wrap_ = false;
|
2016-10-04 18:42:13 +00:00
|
|
|
} else if (strcmp(argv[i], "--module") == 0) {
|
|
|
|
|
options.module_ = true;
|
2016-02-19 12:36:26 +00:00
|
|
|
} else if (strcmp(argv[i], "--top-level") == 0) {
|
|
|
|
|
options.top_level_ = true;
|
2016-02-19 15:52:48 +00:00
|
|
|
} else if (strcmp(argv[i], "--do-expressions") == 0) {
|
|
|
|
|
options.do_expressions_ = true;
|
2017-02-24 17:48:49 +00:00
|
|
|
} else if (strcmp(argv[i], "--async-iteration") == 0) {
|
|
|
|
|
options.async_iteration_ = true;
|
2017-11-28 09:42:57 +00:00
|
|
|
} else if (strcmp(argv[i], "--public-fields") == 0) {
|
|
|
|
|
options.public_fields_ = true;
|
2017-12-21 17:58:28 +00:00
|
|
|
} else if (strcmp(argv[i], "--static-fields") == 0) {
|
|
|
|
|
options.static_fields_ = true;
|
2016-02-26 12:04:03 +00:00
|
|
|
} else if (strcmp(argv[i], "--verbose") == 0) {
|
|
|
|
|
options.verbose_ = true;
|
2016-02-19 12:36:26 +00:00
|
|
|
} else if (strncmp(argv[i], "--output=", 9) == 0) {
|
|
|
|
|
options.output_filename_ = argv[i] + 9;
|
|
|
|
|
} else if (strncmp(argv[i], "--test-function-name=", 21) == 0) {
|
|
|
|
|
options.test_function_name_ = argv[i] + 21;
|
[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
|
|
|
} else if (strncmp(argv[i], "--", 2) != 0) { // It doesn't start with --
|
2016-02-26 12:04:03 +00:00
|
|
|
options.input_filenames_.push_back(argv[i]);
|
[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
|
|
|
} else {
|
2016-03-16 14:41:05 +00:00
|
|
|
REPORT_ERROR("Unknown option " << argv[i]);
|
[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
|
|
|
options.parsing_failed_ = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (options.rebaseline_ && options.input_filenames_.empty()) {
|
|
|
|
|
#ifdef V8_OS_POSIX
|
|
|
|
|
if (options.verbose_) {
|
|
|
|
|
std::cout << "Looking for golden files in " << kGoldenFilesPath << '\n';
|
|
|
|
|
}
|
|
|
|
|
if (!CollectGoldenFiles(&options.input_filenames_, kGoldenFilesPath)) {
|
|
|
|
|
REPORT_ERROR("Golden files autodiscovery failed.");
|
|
|
|
|
options.parsing_failed_ = true;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
REPORT_ERROR("Golden files autodiscovery requires a POSIX OS, sorry.");
|
|
|
|
|
options.parsing_failed_ = true;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
[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
|
|
|
return options;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ProgramOptions::Validate() const {
|
|
|
|
|
if (parsing_failed_) return false;
|
|
|
|
|
if (print_help_) return true;
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (!read_from_stdin_ && input_filenames_.empty()) {
|
|
|
|
|
REPORT_ERROR("No input file specified.");
|
[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
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (read_from_stdin_ && !input_filenames_.empty()) {
|
|
|
|
|
REPORT_ERROR("Reading from stdin, but input files supplied.");
|
[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
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
if (rebaseline_ && read_raw_js_snippet_) {
|
2016-02-26 12:04:03 +00:00
|
|
|
REPORT_ERROR("Cannot use --rebaseline on a raw JS snippet.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rebaseline_ && !output_filename_.empty()) {
|
|
|
|
|
REPORT_ERROR("Output file cannot be specified together with --rebaseline.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (rebaseline_ && read_from_stdin_) {
|
|
|
|
|
REPORT_ERROR("Cannot --rebaseline when input is --stdin.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (input_filenames_.size() > 1 && !rebaseline_ && !read_raw_js_snippet()) {
|
|
|
|
|
REPORT_ERROR(
|
|
|
|
|
"Multiple input files, but no --rebaseline or --raw-js specified.");
|
2016-02-19 12:36:26 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (top_level_ && !test_function_name_.empty()) {
|
2016-02-26 12:04:03 +00:00
|
|
|
REPORT_ERROR(
|
|
|
|
|
"Test function name specified while processing top level code.");
|
2016-02-19 12:36:26 +00:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-04 18:42:13 +00:00
|
|
|
if (module_ && (!top_level_ || wrap_)) {
|
|
|
|
|
REPORT_ERROR(
|
|
|
|
|
"The flag --module currently requires --top-level and --no-wrap.");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
[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
|
|
|
return true;
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
void ProgramOptions::UpdateFromHeader(std::istream& stream) {
|
|
|
|
|
std::string line;
|
|
|
|
|
|
|
|
|
|
// Skip to the beginning of the options header
|
|
|
|
|
while (std::getline(stream, line)) {
|
|
|
|
|
if (line == "---") break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (std::getline(stream, line)) {
|
2016-10-04 18:42:13 +00:00
|
|
|
if (line.compare(0, 8, "module: ") == 0) {
|
|
|
|
|
module_ = ParseBoolean(line.c_str() + 8);
|
|
|
|
|
} else if (line.compare(0, 6, "wrap: ") == 0) {
|
2016-02-19 12:36:26 +00:00
|
|
|
wrap_ = ParseBoolean(line.c_str() + 6);
|
|
|
|
|
} else if (line.compare(0, 20, "test function name: ") == 0) {
|
|
|
|
|
test_function_name_ = line.c_str() + 20;
|
|
|
|
|
} else if (line.compare(0, 11, "top level: ") == 0) {
|
|
|
|
|
top_level_ = ParseBoolean(line.c_str() + 11);
|
2016-02-19 15:52:48 +00:00
|
|
|
} else if (line.compare(0, 16, "do expressions: ") == 0) {
|
|
|
|
|
do_expressions_ = ParseBoolean(line.c_str() + 16);
|
2017-02-24 17:48:49 +00:00
|
|
|
} else if (line.compare(0, 17, "async iteration: ") == 0) {
|
|
|
|
|
async_iteration_ = ParseBoolean(line.c_str() + 17);
|
2017-11-28 12:27:07 +00:00
|
|
|
} else if (line.compare(0, 15, "public fields: ") == 0) {
|
|
|
|
|
public_fields_ = ParseBoolean(line.c_str() + 15);
|
2017-12-21 17:58:28 +00:00
|
|
|
} else if (line.compare(0, 15, "static fields: ") == 0) {
|
|
|
|
|
static_fields_ = ParseBoolean(line.c_str() + 15);
|
2016-02-19 12:36:26 +00:00
|
|
|
} else if (line == "---") {
|
|
|
|
|
break;
|
|
|
|
|
} else if (line.empty()) {
|
|
|
|
|
continue;
|
|
|
|
|
} else {
|
|
|
|
|
UNREACHABLE();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ProgramOptions::PrintHeader(std::ostream& stream) const { // NOLINT
|
|
|
|
|
stream << "---"
|
|
|
|
|
<< "\nwrap: " << BooleanToString(wrap_);
|
|
|
|
|
|
|
|
|
|
if (!test_function_name_.empty()) {
|
|
|
|
|
stream << "\ntest function name: " << test_function_name_;
|
|
|
|
|
}
|
|
|
|
|
|
2016-10-04 18:42:13 +00:00
|
|
|
if (module_) stream << "\nmodule: yes";
|
2016-02-19 12:36:26 +00:00
|
|
|
if (top_level_) stream << "\ntop level: yes";
|
2016-02-19 15:52:48 +00:00
|
|
|
if (do_expressions_) stream << "\ndo expressions: yes";
|
2017-02-24 17:48:49 +00:00
|
|
|
if (async_iteration_) stream << "\nasync iteration: yes";
|
2017-11-28 09:42:57 +00:00
|
|
|
if (public_fields_) stream << "\npublic fields: yes";
|
2017-12-21 17:58:28 +00:00
|
|
|
if (static_fields_) stream << "\nstatic fields: yes";
|
2016-02-19 12:36:26 +00:00
|
|
|
|
|
|
|
|
stream << "\n\n";
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-10 11:26:14 +00:00
|
|
|
V8InitializationScope::V8InitializationScope(const char* exec_path)
|
2017-11-13 13:16:49 +00:00
|
|
|
: platform_(v8::platform::NewDefaultPlatform()) {
|
2016-02-10 11:26:14 +00:00
|
|
|
i::FLAG_always_opt = false;
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
|
2016-06-08 12:09:25 +00:00
|
|
|
v8::V8::InitializeICUDefaultLocation(exec_path);
|
2016-02-10 11:26:14 +00:00
|
|
|
v8::V8::InitializeExternalStartupData(exec_path);
|
|
|
|
|
v8::V8::InitializePlatform(platform_.get());
|
|
|
|
|
v8::V8::Initialize();
|
|
|
|
|
|
|
|
|
|
v8::Isolate::CreateParams create_params;
|
2016-07-25 11:12:42 +00:00
|
|
|
allocator_.reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
|
2016-06-29 07:39:45 +00:00
|
|
|
create_params.array_buffer_allocator = allocator_.get();
|
2016-02-10 11:26:14 +00:00
|
|
|
|
|
|
|
|
isolate_ = v8::Isolate::New(create_params);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
V8InitializationScope::~V8InitializationScope() {
|
|
|
|
|
isolate_->Dispose();
|
|
|
|
|
v8::V8::Dispose();
|
|
|
|
|
v8::V8::ShutdownPlatform();
|
|
|
|
|
}
|
|
|
|
|
|
[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
|
|
|
std::string ReadRawJSSnippet(std::istream& stream) { // NOLINT
|
|
|
|
|
std::stringstream body_buffer;
|
|
|
|
|
CHECK(body_buffer << stream.rdbuf());
|
|
|
|
|
return body_buffer.str();
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
[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
|
|
|
bool ReadNextSnippet(std::istream& stream, std::string* string_out) { // NOLINT
|
|
|
|
|
std::string line;
|
|
|
|
|
bool found_begin_snippet = false;
|
|
|
|
|
string_out->clear();
|
|
|
|
|
while (std::getline(stream, line)) {
|
|
|
|
|
if (line == "snippet: \"") {
|
|
|
|
|
found_begin_snippet = true;
|
|
|
|
|
continue;
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
[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
|
|
|
if (!found_begin_snippet) continue;
|
|
|
|
|
if (line == "\"") return true;
|
|
|
|
|
CHECK_GE(line.size(), 2u); // We should have the indent
|
|
|
|
|
string_out->append(line.begin() + 2, line.end());
|
|
|
|
|
*string_out += '\n';
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
[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
|
|
|
return false;
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
std::string UnescapeString(const std::string& escaped_string) {
|
|
|
|
|
std::string unescaped_string;
|
|
|
|
|
bool previous_was_backslash = false;
|
|
|
|
|
for (char c : escaped_string) {
|
|
|
|
|
if (previous_was_backslash) {
|
|
|
|
|
// If it was not an escape sequence, emit the previous backslash
|
|
|
|
|
if (c != '\\' && c != '"') unescaped_string += '\\';
|
|
|
|
|
unescaped_string += c;
|
|
|
|
|
previous_was_backslash = false;
|
|
|
|
|
} else {
|
|
|
|
|
if (c == '\\') {
|
|
|
|
|
previous_was_backslash = true;
|
|
|
|
|
// Defer emission to the point where we can check if it was an escape.
|
|
|
|
|
} else {
|
|
|
|
|
unescaped_string += c;
|
|
|
|
|
}
|
2016-02-10 18:35:31 +00:00
|
|
|
}
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
2016-02-19 12:36:26 +00:00
|
|
|
return unescaped_string;
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
void ExtractSnippets(std::vector<std::string>* snippet_list,
|
|
|
|
|
std::istream& body_stream, // NOLINT
|
|
|
|
|
bool read_raw_js_snippet) {
|
|
|
|
|
if (read_raw_js_snippet) {
|
|
|
|
|
snippet_list->push_back(ReadRawJSSnippet(body_stream));
|
[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
|
|
|
} else {
|
2016-02-19 12:36:26 +00:00
|
|
|
std::string snippet;
|
|
|
|
|
while (ReadNextSnippet(body_stream, &snippet)) {
|
|
|
|
|
snippet_list->push_back(UnescapeString(snippet));
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
|
|
|
|
}
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-19 12:36:26 +00:00
|
|
|
void GenerateExpectationsFile(std::ostream& stream, // NOLINT
|
|
|
|
|
const std::vector<std::string>& snippet_list,
|
2016-02-26 12:04:03 +00:00
|
|
|
const V8InitializationScope& platform,
|
|
|
|
|
const ProgramOptions& options) {
|
|
|
|
|
v8::Isolate::Scope isolate_scope(platform.isolate());
|
|
|
|
|
v8::HandleScope handle_scope(platform.isolate());
|
|
|
|
|
v8::Local<v8::Context> context = v8::Context::New(platform.isolate());
|
|
|
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
|
|
2016-09-06 16:10:19 +00:00
|
|
|
BytecodeExpectationsPrinter printer(platform.isolate());
|
2016-02-26 12:04:03 +00:00
|
|
|
printer.set_wrap(options.wrap());
|
2016-10-04 18:42:13 +00:00
|
|
|
printer.set_module(options.module());
|
2016-02-26 12:04:03 +00:00
|
|
|
printer.set_top_level(options.top_level());
|
|
|
|
|
if (!options.test_function_name().empty()) {
|
|
|
|
|
printer.set_test_function_name(options.test_function_name());
|
|
|
|
|
}
|
2016-02-10 11:26:14 +00:00
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (options.do_expressions()) i::FLAG_harmony_do_expressions = true;
|
2017-11-28 09:42:57 +00:00
|
|
|
if (options.public_fields()) i::FLAG_harmony_public_fields = true;
|
2017-12-21 17:58:28 +00:00
|
|
|
if (options.static_fields()) i::FLAG_harmony_static_fields = true;
|
2016-02-19 15:52:48 +00:00
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
stream << "#\n# Autogenerated by generate-bytecode-expectations.\n#\n\n";
|
|
|
|
|
options.PrintHeader(stream);
|
|
|
|
|
for (const std::string& snippet : snippet_list) {
|
|
|
|
|
printer.PrintExpectation(stream, snippet);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i::FLAG_harmony_do_expressions = false;
|
2017-11-28 09:42:57 +00:00
|
|
|
i::FLAG_harmony_public_fields = false;
|
2017-12-21 17:58:28 +00:00
|
|
|
i::FLAG_harmony_static_fields = false;
|
2016-02-26 12:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool WriteExpectationsFile(const std::vector<std::string>& snippet_list,
|
|
|
|
|
const V8InitializationScope& platform,
|
|
|
|
|
const ProgramOptions& options,
|
|
|
|
|
const std::string& output_filename) {
|
|
|
|
|
std::ofstream output_file_handle;
|
|
|
|
|
if (!options.write_to_stdout()) {
|
|
|
|
|
output_file_handle.open(output_filename.c_str());
|
|
|
|
|
if (!output_file_handle.is_open()) {
|
|
|
|
|
REPORT_ERROR("Could not open " << output_filename << " for writing.");
|
|
|
|
|
return false;
|
[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
|
|
|
}
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
2016-02-26 12:04:03 +00:00
|
|
|
std::ostream& output_stream =
|
|
|
|
|
options.write_to_stdout() ? std::cout : output_file_handle;
|
|
|
|
|
|
|
|
|
|
GenerateExpectationsFile(output_stream, snippet_list, platform, options);
|
|
|
|
|
|
|
|
|
|
return true;
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
}
|
|
|
|
|
|
2016-03-01 10:41:56 +00:00
|
|
|
void PrintMessage(v8::Local<v8::Message> message, v8::Local<v8::Value>) {
|
2017-08-29 00:17:03 +00:00
|
|
|
std::cerr << "INFO: "
|
|
|
|
|
<< *v8::String::Utf8Value(v8::Isolate::GetCurrent(), message->Get())
|
|
|
|
|
<< '\n';
|
2016-03-01 10:41:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void DiscardMessage(v8::Local<v8::Message>, v8::Local<v8::Value>) {}
|
|
|
|
|
|
2016-02-10 11:26:14 +00:00
|
|
|
void PrintUsage(const char* exec_path) {
|
[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
|
|
|
std::cerr
|
|
|
|
|
<< "\nUsage: " << exec_path
|
2016-02-26 12:04:03 +00:00
|
|
|
<< " [OPTIONS]... [INPUT FILES]...\n\n"
|
[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
|
|
|
"Options:\n"
|
|
|
|
|
" --help Print this help message.\n"
|
2016-02-26 12:04:03 +00:00
|
|
|
" --verbose Emit messages about the progress of the tool.\n"
|
[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
|
|
|
" --raw-js Read raw JavaScript, instead of the output format.\n"
|
|
|
|
|
" --stdin Read from standard input instead of file.\n"
|
2016-02-19 12:36:26 +00:00
|
|
|
" --rebaseline Rebaseline input snippet file.\n"
|
|
|
|
|
" --no-wrap Do not wrap the snippet in a function.\n"
|
2016-10-04 18:42:13 +00:00
|
|
|
" --module Compile as JavaScript module.\n"
|
2016-02-19 12:36:26 +00:00
|
|
|
" --test-function-name=foo "
|
|
|
|
|
"Specify the name of the test function.\n"
|
2016-02-26 12:04:03 +00:00
|
|
|
" --top-level Process top level code, not the top-level function.\n"
|
2016-02-19 15:52:48 +00:00
|
|
|
" --do-expressions Enable harmony_do_expressions flag.\n"
|
2017-11-28 09:42:57 +00:00
|
|
|
" --public-fields Enable harmony_public_fields flag.\n"
|
2017-12-21 17:58:28 +00:00
|
|
|
" --static-fields Enable harmony_static_fields flag.\n"
|
2016-02-19 12:36:26 +00:00
|
|
|
" --output=file.name\n"
|
|
|
|
|
" Specify the output file. If not specified, output goes to "
|
|
|
|
|
"stdout.\n"
|
2016-02-19 16:14:07 +00:00
|
|
|
" --pool-type=(number|string|mixed)\n"
|
2016-02-19 12:36:26 +00:00
|
|
|
" Specify the type of the entries in the constant pool "
|
[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
|
|
|
"(default: mixed).\n"
|
|
|
|
|
"\n"
|
2016-10-04 16:29:59 +00:00
|
|
|
"When using --rebaseline, flags --no-wrap, --test-function-name \n"
|
|
|
|
|
"and --pool-type will be overridden by the options specified in \n"
|
|
|
|
|
"the input file header.\n\n"
|
[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
|
|
|
"Each raw JavaScript file is interpreted as a single snippet.\n\n"
|
|
|
|
|
"This tool is intended as a help in writing tests.\n"
|
|
|
|
|
"Please, DO NOT blindly copy and paste the output "
|
|
|
|
|
"into the test suite.\n";
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
int main(int argc, char** argv) {
|
[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
|
|
|
ProgramOptions options = ProgramOptions::FromCommandLine(argc, argv);
|
[Interpreter] Print constant pool in generate-bytecode-expectations
This is a follow-up to https://crrev.com/1671863002, adding the
capability to print the contents of the constant pool. The expected
type of the pool is taken from command line, and it's either:
* string/int/double: assume all constants have the specified type.
This way, we can emit a meaningful representation, e.g. a quoted
string for type string and so on. All the constants in the pool must
have the same type, otherwise one or more CHECK() will fail and the
program will eventually crash.
* mixed: print the InstanceType tag instead of the actual value.
This is the choice for those tests where the type of the constants in
the pool is not uniform, however only a type tag is printed, not the
actual value of the entries. SMIs are an exception, since they do not
have an InstanceType tag, so kInstanceTypeDontCare is printed instead.
In addition to that, functions Print{ExpectedSnippet,BytecodeSequence}
have been extracted with no functional change. It's just for improving
readability, since the code is becoming quite long.
BUG=v8:4280
LOG=N
Review URL: https://codereview.chromium.org/1686963002
Cr-Commit-Position: refs/heads/master@{#33888}
2016-02-11 11:26:41 +00:00
|
|
|
|
[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
|
|
|
if (!options.Validate() || options.print_help()) {
|
2016-02-10 11:26:14 +00:00
|
|
|
PrintUsage(argv[0]);
|
[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
|
|
|
return options.print_help() ? 0 : 1;
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
V8InitializationScope platform(argv[0]);
|
2016-03-01 10:41:56 +00:00
|
|
|
platform.isolate()->AddMessageListener(
|
|
|
|
|
options.suppress_runtime_errors() ? DiscardMessage : PrintMessage);
|
2016-02-19 12:36:26 +00:00
|
|
|
|
[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
|
|
|
std::vector<std::string> snippet_list;
|
2016-02-19 12:36:26 +00:00
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (options.read_from_stdin()) {
|
|
|
|
|
// Rebaseline will never get here, so we will always take the
|
|
|
|
|
// GenerateExpectationsFile at the end of this function.
|
|
|
|
|
DCHECK(!options.rebaseline());
|
|
|
|
|
ExtractSnippets(&snippet_list, std::cin, options.read_raw_js_snippet());
|
|
|
|
|
} else {
|
|
|
|
|
for (const std::string& input_filename : options.input_filenames()) {
|
|
|
|
|
if (options.verbose()) {
|
|
|
|
|
std::cerr << "Processing " << input_filename << '\n';
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::ifstream input_stream(input_filename.c_str());
|
|
|
|
|
if (!input_stream.is_open()) {
|
|
|
|
|
REPORT_ERROR("Could not open " << input_filename << " for reading.");
|
|
|
|
|
return 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ProgramOptions updated_options = options;
|
|
|
|
|
if (options.rebaseline()) {
|
|
|
|
|
updated_options.UpdateFromHeader(input_stream);
|
|
|
|
|
CHECK(updated_options.Validate());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ExtractSnippets(&snippet_list, input_stream,
|
|
|
|
|
options.read_raw_js_snippet());
|
|
|
|
|
|
|
|
|
|
if (options.rebaseline()) {
|
|
|
|
|
if (!WriteExpectationsFile(snippet_list, platform, updated_options,
|
|
|
|
|
input_filename)) {
|
|
|
|
|
return 3;
|
|
|
|
|
}
|
|
|
|
|
snippet_list.clear();
|
|
|
|
|
}
|
2016-02-19 12:36:26 +00:00
|
|
|
}
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
|
|
|
|
|
2016-02-26 12:04:03 +00:00
|
|
|
if (!options.rebaseline()) {
|
|
|
|
|
if (!WriteExpectationsFile(snippet_list, platform, options,
|
|
|
|
|
options.output_filename())) {
|
|
|
|
|
return 3;
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-02-10 11:26:14 +00:00
|
|
|
}
|
