AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
043ac205ec
v8/test/cctest/interpreter/generate-bytecode-expectations.cc
Joshua Litt 0ceee9ad28 [top-level-await] Add support for parsing top level await 
Adds support for parsing top level await to V8, as well as
many tests.

This is the final cl in the series to add support for top level
await to v8.

Spec is here:
https://tc39.es/proposal-top-level-await/#sec-execute-async-module

Bug: v8:9344
Change-Id: Ie8f17ad8c7c60d1f6996d134ae154416cc1f31e3
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1703878
Reviewed-by: Georg Neis <neis@chromium.org>
Reviewed-by: Adam Klein <adamk@chromium.org>
Commit-Queue: Joshua Litt <joshualitt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#63946}
2019-09-24 14:01:32 +00:00

675 lines
23 KiB
C++
Raw Blame History

// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <algorithm>
#include <cstring>
#include <fstream>
#include <memory>
#include <sstream>
#include <vector>
#include "test/cctest/interpreter/bytecode-expectations-printer.h"
#include "include/libplatform/libplatform.h"
#include "include/v8.h"
#include "src/base/logging.h"
#include "src/interpreter/interpreter.h"
#ifdef V8_OS_POSIX
#include <dirent.h>
#endif
using v8::internal::interpreter::BytecodeExpectationsPrinter;
#define REPORT_ERROR(MESSAGE) (((std::cerr << "ERROR: ") << MESSAGE) << '\n')
namespace {
const char* kGoldenFilesPath = "test/cctest/interpreter/bytecode_expectations/";
class ProgramOptions final {
public:
static ProgramOptions FromCommandLine(int argc, char** argv);
ProgramOptions()
: parsing_failed_(false),
print_help_(false),
read_raw_js_snippet_(false),
read_from_stdin_(false),
rebaseline_(false),
check_baseline_(false),
wrap_(true),
module_(false),
top_level_(false),
print_callee_(false),
oneshot_opt_(false),
async_iteration_(false),
private_methods_(false),
top_level_await_(false),
verbose_(false) {}
bool Validate() const;
void UpdateFromHeader(std::istream* stream);
void PrintHeader(std::ostream* stream) const;
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_; }
bool write_to_stdout() const {
return output_filename_.empty() && !rebaseline_;
}
bool rebaseline() const { return rebaseline_; }
bool check_baseline() const { return check_baseline_; }
bool baseline() const { return rebaseline_ || check_baseline_; }
bool wrap() const { return wrap_; }
bool module() const { return module_; }
bool top_level() const { return top_level_; }
bool print_callee() const { return print_callee_; }
bool oneshot_opt() const { return oneshot_opt_; }
bool async_iteration() const { return async_iteration_; }
bool private_methods() const { return private_methods_; }
bool top_level_await() const { return top_level_await_; }
bool verbose() const { return verbose_; }
bool suppress_runtime_errors() const { return baseline() && !verbose_; }
std::vector<std::string> input_filenames() const { return input_filenames_; }
std::string output_filename() const { return output_filename_; }
std::string test_function_name() const { return test_function_name_; }
private:
bool parsing_failed_;
bool print_help_;
bool read_raw_js_snippet_;
bool read_from_stdin_;
bool rebaseline_;
bool check_baseline_;
bool wrap_;
bool module_;
bool top_level_;
bool print_callee_;
bool oneshot_opt_;
bool async_iteration_;
bool private_methods_;
bool top_level_await_;
bool verbose_;
std::vector<std::string> input_filenames_;
std::string output_filename_;
std::string test_function_name_;
};
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:
std::unique_ptr<v8::Platform> platform_;
std::unique_ptr<v8::ArrayBuffer::Allocator> allocator_;
v8::Isolate* isolate_;
DISALLOW_COPY_AND_ASSIGN(V8InitializationScope);
};
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"; }
bool CollectGoldenFiles(std::vector<std::string>* golden_file_list,
const char* directory_path) {
#ifdef V8_OS_POSIX
DIR* directory = opendir(directory_path);
if (!directory) return false;
auto str_ends_with = [](const char* string, const char* suffix) {
size_t string_size = strlen(string);
size_t suffix_size = strlen(suffix);
if (string_size < suffix_size) return false;
return strcmp(string + (string_size - suffix_size), suffix) == 0;
};
dirent* entry = readdir(directory);
while (entry) {
if (str_ends_with(entry->d_name, ".golden")) {
std::string golden_filename(kGoldenFilesPath);
golden_filename += entry->d_name;
golden_file_list->push_back(golden_filename);
}
entry = readdir(directory);
}
closedir(directory);
#elif V8_OS_WIN
std::string search_path(directory_path + std::string("/*.golden"));
WIN32_FIND_DATAA fd;
HANDLE find_handle = FindFirstFileA(search_path.c_str(), &fd);
if (find_handle == INVALID_HANDLE_VALUE) return false;
do {
if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
std::string golden_filename(kGoldenFilesPath);
std::string temp_filename(fd.cFileName);
golden_filename += temp_filename;
golden_file_list->push_back(golden_filename);
}
} while (FindNextFileA(find_handle, &fd));
FindClose(find_handle);
#endif // V8_OS_POSIX
return true;
}
// 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;
} else if (strcmp(argv[i], "--rebaseline") == 0) {
options.rebaseline_ = true;
} else if (strcmp(argv[i], "--check-baseline") == 0) {
options.check_baseline_ = true;
} else if (strcmp(argv[i], "--no-wrap") == 0) {
options.wrap_ = false;
} else if (strcmp(argv[i], "--module") == 0) {
options.module_ = true;
} else if (strcmp(argv[i], "--top-level") == 0) {
options.top_level_ = true;
} else if (strcmp(argv[i], "--print-callee") == 0) {
options.print_callee_ = true;
} else if (strcmp(argv[i], "--disable-oneshot-opt") == 0) {
options.oneshot_opt_ = false;
} else if (strcmp(argv[i], "--async-iteration") == 0) {
options.async_iteration_ = true;
} else if (strcmp(argv[i], "--private-methods") == 0) {
options.private_methods_ = true;
} else if (strcmp(argv[i], "--harmony-top-level-await") == 0) {
options.top_level_await_ = true;
} else if (strcmp(argv[i], "--verbose") == 0) {
options.verbose_ = true;
} 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;
} else if (strncmp(argv[i], "--", 2) != 0) { // It doesn't start with --
options.input_filenames_.push_back(argv[i]);
} else {
REPORT_ERROR("Unknown option " << argv[i]);
options.parsing_failed_ = true;
break;
}
}
if (options.rebaseline() && options.check_baseline()) {
REPORT_ERROR("Can't check baseline and rebaseline at the same time.");
std::exit(1);
}
if ((options.check_baseline_ || options.rebaseline_) &&
options.input_filenames_.empty()) {
#if defined(V8_OS_POSIX) || defined(V8_OS_WIN)
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 or Window OS, sorry.");
options.parsing_failed_ = true;
#endif
}
return options;
}
bool ProgramOptions::Validate() const {
if (parsing_failed_) return false;
if (print_help_) return true;
if (!read_from_stdin_ && input_filenames_.empty()) {
REPORT_ERROR("No input file specified.");
return false;
}
if (read_from_stdin_ && !input_filenames_.empty()) {
REPORT_ERROR("Reading from stdin, but input files supplied.");
return false;
}
if (baseline() && read_raw_js_snippet_) {
REPORT_ERROR(
"Cannot use --rebaseline or --check-baseline on a raw JS snippet.");
return false;
}
if (baseline() && !output_filename_.empty()) {
REPORT_ERROR(
"Output file cannot be specified together with --rebaseline or "
"--check-baseline.");
return false;
}
if (baseline() && read_from_stdin_) {
REPORT_ERROR(
"Cannot --rebaseline or --check-baseline when input is --stdin.");
return false;
}
if (input_filenames_.size() > 1 && !baseline() && !read_raw_js_snippet()) {
REPORT_ERROR(
"Multiple input files, but no --rebaseline, --check-baseline or "
"--raw-js specified.");
return false;
}
if (top_level_ && !test_function_name_.empty()) {
REPORT_ERROR(
"Test function name specified while processing top level code.");
return false;
}
if (module_ && (!top_level_ || wrap_)) {
REPORT_ERROR(
"The flag --module currently requires --top-level and --no-wrap.");
return false;
}
return true;
}
void ProgramOptions::UpdateFromHeader(std::istream* stream) {
std::string line;
const char* kPrintCallee = "print callee: ";
const char* kOneshotOpt = "oneshot opt: ";
// Skip to the beginning of the options header
while (std::getline(*stream, line)) {
if (line == "---") break;
}
while (std::getline(*stream, line)) {
if (line.compare(0, 8, "module: ") == 0) {
module_ = ParseBoolean(line.c_str() + 8);
} else if (line.compare(0, 6, "wrap: ") == 0) {
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);
} else if (line.compare(0, strlen(kPrintCallee), kPrintCallee) == 0) {
print_callee_ = ParseBoolean(line.c_str() + strlen(kPrintCallee));
} else if (line.compare(0, strlen(kOneshotOpt), kOneshotOpt) == 0) {
oneshot_opt_ = ParseBoolean(line.c_str() + strlen(kOneshotOpt));
} else if (line.compare(0, 17, "async iteration: ") == 0) {
async_iteration_ = ParseBoolean(line.c_str() + 17);
} else if (line.compare(0, 17, "private methods: ") == 0) {
private_methods_ = ParseBoolean(line.c_str() + 17);
} else if (line.compare(0, 17, "top level await: ") == 0) {
top_level_await_ = ParseBoolean(line.c_str() + 17);
} else if (line == "---") {
break;
} else if (line.empty()) {
continue;
} else {
UNREACHABLE();
}
}
}
void ProgramOptions::PrintHeader(std::ostream* stream) const {
*stream << "---"
<< "\nwrap: " << BooleanToString(wrap_);
if (!test_function_name_.empty()) {
*stream << "\ntest function name: " << test_function_name_;
}
if (module_) *stream << "\nmodule: yes";
if (top_level_) *stream << "\ntop level: yes";
if (print_callee_) *stream << "\nprint callee: yes";
if (oneshot_opt_) *stream << "\noneshot opt: yes";
if (async_iteration_) *stream << "\nasync iteration: yes";
if (private_methods_) *stream << "\nprivate methods: yes";
if (top_level_await_) *stream << "\ntop level await: yes";
*stream << "\n\n";
}
V8InitializationScope::V8InitializationScope(const char* exec_path)
: platform_(v8::platform::NewDefaultPlatform()) {
i::FLAG_always_opt = false;
i::FLAG_allow_natives_syntax = true;
i::FLAG_enable_lazy_source_positions = false;
v8::V8::InitializeICUDefaultLocation(exec_path);
v8::V8::InitializeExternalStartupData(exec_path);
v8::V8::InitializePlatform(platform_.get());
v8::V8::Initialize();
v8::Isolate::CreateParams create_params;
allocator_.reset(v8::ArrayBuffer::Allocator::NewDefaultAllocator());
create_params.array_buffer_allocator = allocator_.get();
isolate_ = v8::Isolate::New(create_params);
}
V8InitializationScope::~V8InitializationScope() {
isolate_->Dispose();
v8::V8::Dispose();
v8::V8::ShutdownPlatform();
}
std::string ReadRawJSSnippet(std::istream* stream) {
std::stringstream body_buffer;
CHECK(body_buffer << stream->rdbuf());
return body_buffer.str();
}
bool ReadNextSnippet(std::istream* stream, std::string* string_out) {
std::string line;
bool found_begin_snippet = false;
string_out->clear();
while (std::getline(*stream, line)) {
if (line == "snippet: \"") {
found_begin_snippet = true;
continue;
}
if (!found_begin_snippet) continue;
if (line == "\"") return true;
if (line.size() == 0) {
string_out->append("\n"); // consume empty line
continue;
}
CHECK_GE(line.size(), 2u); // We should have the indent
string_out->append(line.begin() + 2, line.end());
*string_out += '\n';
}
return false;
}
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;
}
}
}
return unescaped_string;
}
void ExtractSnippets(std::vector<std::string>* snippet_list,
std::istream* body_stream, bool read_raw_js_snippet) {
if (read_raw_js_snippet) {
snippet_list->push_back(ReadRawJSSnippet(body_stream));
} else {
std::string snippet;
while (ReadNextSnippet(body_stream, &snippet)) {
snippet_list->push_back(UnescapeString(snippet));
}
}
}
void GenerateExpectationsFile(std::ostream* stream,
const std::vector<std::string>& snippet_list,
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);
BytecodeExpectationsPrinter printer(platform.isolate());
printer.set_wrap(options.wrap());
printer.set_module(options.module());
printer.set_top_level(options.top_level());
printer.set_print_callee(options.print_callee());
printer.set_oneshot_opt(options.oneshot_opt());
if (!options.test_function_name().empty()) {
printer.set_test_function_name(options.test_function_name());
}
if (options.private_methods()) i::FLAG_harmony_private_methods = true;
if (options.top_level_await()) i::FLAG_harmony_top_level_await = true;
*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_private_methods = false;
i::FLAG_harmony_top_level_await = false;
}
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;
}
}
std::ostream& output_stream =
options.write_to_stdout() ? std::cout : output_file_handle;
GenerateExpectationsFile(&output_stream, snippet_list, platform, options);
return true;
}
std::string WriteExpectationsToString(
const std::vector<std::string>& snippet_list,
const V8InitializationScope& platform, const ProgramOptions& options) {
std::stringstream output_string;
GenerateExpectationsFile(&output_string, snippet_list, platform, options);
return output_string.str();
}
void PrintMessage(v8::Local<v8::Message> message, v8::Local<v8::Value>) {
std::cerr << "INFO: "
<< *v8::String::Utf8Value(message->GetIsolate(), message->Get())
<< '\n';
}
void DiscardMessage(v8::Local<v8::Message>, v8::Local<v8::Value>) {}
void PrintUsage(const char* exec_path) {
std::cerr
<< "\nUsage: " << exec_path
<< " [OPTIONS]... [INPUT FILES]...\n\n"
"Options:\n"
" --help Print this help message.\n"
" --verbose Emit messages about the progress of the tool.\n"
" --raw-js Read raw JavaScript, instead of the output format.\n"
" --stdin Read from standard input instead of file.\n"
" --rebaseline Rebaseline input snippet file.\n"
" --check-baseline Checks the current baseline is valid.\n"
" --no-wrap Do not wrap the snippet in a function.\n"
" --disable-oneshot-opt Disable Oneshot Optimization.\n"
" --print-callee Print bytecode of callee, function should "
"return arguments.callee.\n"
" --module Compile as JavaScript module.\n"
" --test-function-name=foo "
"Specify the name of the test function.\n"
" --top-level Process top level code, not the top-level function.\n"
" --private-methods Enable harmony_private_methods flag.\n"
" --top-level-await Enable await at the module level.\n"
" --output=file.name\n"
" Specify the output file. If not specified, output goes to "
"stdout.\n"
" --pool-type=(number|string|mixed)\n"
" Specify the type of the entries in the constant pool "
"(default: mixed).\n"
"\n"
"When using --rebaseline or --check-baseline, flags --no-wrap,\n"
"--test-function-name and --pool-type will be overridden by the\n"
"options specified in the input file header.\n\n"
"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";
}
} // namespace
bool CheckBaselineExpectations(const std::string& input_filename,
const std::vector<std::string>& snippet_list,
const V8InitializationScope& platform,
const ProgramOptions& options) {
std::string actual =
WriteExpectationsToString(snippet_list, platform, options);
std::ifstream input_stream(input_filename);
if (!input_stream.is_open()) {
REPORT_ERROR("Could not open " << input_filename << " for reading.");
std::exit(2);
}
bool check_failed = false;
std::string expected((std::istreambuf_iterator<char>(input_stream)),
std::istreambuf_iterator<char>());
if (expected != actual) {
REPORT_ERROR("Mismatch: " << input_filename);
check_failed = true;
if (expected.size() != actual.size()) {
REPORT_ERROR(" Expected size (" << expected.size()
<< ") != actual size (" << actual.size()
<< ")");
}
int line = 1;
for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {
if (expected[i] != actual[i]) {
// Find the start of the line that has the mismatch carefully
// handling the case where it's the first line that mismatches.
size_t start = expected[i] != '\n' ? expected.rfind("\n", i)
: actual.rfind("\n", i);
if (start == std::string::npos) {
start = 0;
} else {
++start;
}
// If there is no new line, then these two lines will consume the
// remaining characters in the string, because npos - start will
// always be longer than the string itself.
std::string expected_line =
expected.substr(start, expected.find("\n", i) - start);
std::string actual_line =
actual.substr(start, actual.find("\n", i) - start);
REPORT_ERROR(" First mismatch on line " << line << ")");
REPORT_ERROR(" Expected : '" << expected_line << "'");
REPORT_ERROR(" Actual : '" << actual_line << "'");
break;
}
if (expected[i] == '\n') line++;
}
}
return check_failed;
}
int main(int argc, char** argv) {
ProgramOptions options = ProgramOptions::FromCommandLine(argc, argv);
if (!options.Validate() || options.print_help()) {
PrintUsage(argv[0]);
return options.print_help() ? 0 : 1;
}
V8InitializationScope platform(argv[0]);
platform.isolate()->AddMessageListener(
options.suppress_runtime_errors() ? DiscardMessage : PrintMessage);
std::vector<std::string> snippet_list;
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() && !options.check_baseline());
ExtractSnippets(&snippet_list, &std::cin, options.read_raw_js_snippet());
} else {
bool check_failed = false;
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.baseline()) {
updated_options.UpdateFromHeader(&input_stream);
CHECK(updated_options.Validate());
}
ExtractSnippets(&snippet_list, &input_stream,
options.read_raw_js_snippet());
input_stream.close();
if (options.rebaseline()) {
if (!WriteExpectationsFile(snippet_list, platform, updated_options,
input_filename)) {
return 3;
}
} else if (options.check_baseline()) {
check_failed |= CheckBaselineExpectations(input_filename, snippet_list,
platform, updated_options);
}
if (options.baseline()) {
snippet_list.clear();
}
}
if (check_failed) {
return 4;
}
}
if (!options.baseline()) {
if (!WriteExpectationsFile(snippet_list, platform, options,
options.output_filename())) {
return 3;
}
}
}
Reference in New Issue View Git Blame Copy Permalink