Two-threaded parser

test/cctest/test-parsing.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 134 matching lines @@
   CcTest::i_isolate()->stack_guard()->SetStackLimit(
       reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(tests[i]));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::PreParser preparser(&scanner, &log, stack_limit, NULL);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(!data.has_error());
   }
 
   for (int i = 0; fail_tests[i]; i++) {
     const i::byte* source =
         reinterpret_cast<const i::byte*>(fail_tests[i]);
     i::Utf8ToUtf16CharacterStream stream(source, i::StrLength(fail_tests[i]));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::PreParser preparser(&scanner, &log, stack_limit, NULL);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     // Even in the case of a syntax error, kPreParseSuccess is returned.
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(data.has_error());
   }
 }
 
 
@@ skipping 165 matching lines @@
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
   for (int i = 0; programs[i]; i++) {
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::PreParser preparser(&scanner, &log, stack_limit, NULL);
     preparser.set_allow_lazy(true);
     preparser.set_allow_natives_syntax(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     CHECK(!data.has_error());
   }
 }
 
 
@@ skipping 14 matching lines @@
   for (int i = 0; programs[i]; i++) {
     const char* program = programs[i];
     i::Utf8ToUtf16CharacterStream stream(
         reinterpret_cast<const i::byte*>(program),
         static_cast<unsigned>(strlen(program)));
     i::CompleteParserRecorder log;
     i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
     scanner.Initialize(&stream);
 
     // Preparser defaults to disallowing natives syntax.
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::PreParser preparser(&scanner, &log, stack_limit, NULL);
     preparser.set_allow_lazy(true);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
     i::ScriptData data(log.ExtractData());
     // Data contains syntax error.
     CHECK(data.has_error());
   }
 }
 
 
@@ skipping 95 matching lines @@
   // Before fix, didn't check *ok after Expect(Token::Identifier, ok),
   // and then used the invalid currently scanned literal. This always
   // failed in debug mode, and sometimes crashed in release mode.
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program),
       static_cast<unsigned>(strlen(program)));
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
-  i::PreParser preparser(&scanner, &log,
-                         CcTest::i_isolate()->stack_guard()->real_climit());
+  i::PreParser preparser(
+      &scanner, &log, CcTest::i_isolate()->stack_guard()->real_climit(), NULL);
   preparser.set_allow_lazy(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   // Even in the case of a syntax error, kPreParseSuccess is returned.
   CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   i::ScriptData data(log.ExtractData());
   CHECK(data.has_error());
 }
 
 
 TEST(Regress928) {
@@ skipping 13 matching lines @@
       "try { } catch (e) { var foo = function () { /* first */ } }"
       "var bar = function () { /* second */ }";
 
   v8::HandleScope handles(CcTest::isolate());
   i::Handle<i::String> source(
       factory->NewStringFromAscii(i::CStrVector(program)));
   i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
-  i::PreParser preparser(&scanner, &log,
-                         CcTest::i_isolate()->stack_guard()->real_climit());
+  i::PreParser preparser(
+      &scanner, &log, CcTest::i_isolate()->stack_guard()->real_climit(), NULL);
   preparser.set_allow_lazy(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   i::ScriptData data(log.ExtractData());
   CHECK(!data.has_error());
   data.Initialize();
 
   int first_function =
       static_cast<int>(strstr(program, "function") - program);
   int first_lbrace = first_function + i::StrLength("function () ");
@@ skipping 26 matching lines @@
 
   uintptr_t stack_limit = CcTest::i_isolate()->stack_guard()->real_climit();
 
   i::Utf8ToUtf16CharacterStream stream(
       reinterpret_cast<const i::byte*>(program.get()),
       static_cast<unsigned>(kProgramSize));
   i::CompleteParserRecorder log;
   i::Scanner scanner(CcTest::i_isolate()->unicode_cache());
   scanner.Initialize(&stream);
 
-  i::PreParser preparser(&scanner, &log, stack_limit);
+  i::PreParser preparser(&scanner, &log, stack_limit, NULL);
   preparser.set_allow_lazy(true);
   i::PreParser::PreParseResult result = preparser.PreParseProgram();
   CHECK_EQ(i::PreParser::kPreParseStackOverflow, result);
 }
 
 
 class TestExternalResource: public v8::String::ExternalStringResource {
  public:
   explicit TestExternalResource(uint16_t* data, int length)
       : data_(data), length_(static_cast<size_t>(length)) { }
@@ skipping 29 matching lines @@
     uc16_buffer[i] = static_cast<i::uc16>(ascii_source[i]);
   }
   i::Vector<const char> ascii_vector(ascii_source, static_cast<int>(length));
   i::Handle<i::String> ascii_string(
       factory->NewStringFromAscii(ascii_vector));
   TestExternalResource resource(uc16_buffer.get(), length);
   i::Handle<i::String> uc16_string(
       factory->NewExternalStringFromTwoByte(&resource).ToHandleChecked());
 
   i::ExternalTwoByteStringUtf16CharacterStream uc16_stream(
-      i::Handle<i::ExternalTwoByteString>::cast(uc16_string), start, end);
+      i::Handle<i::ExternalTwoByteString>::cast(uc16_string)->GetTwoByteData(0),
+      start, end);
   i::GenericStringUtf16CharacterStream string_stream(ascii_string, start, end);
   i::Utf8ToUtf16CharacterStream utf8_stream(
       reinterpret_cast<const i::byte*>(ascii_source), end);
   utf8_stream.SeekForward(start);
 
   unsigned i = start;
   while (i < end) {
     // Read streams one char at a time
     CHECK_EQU(i, uc16_stream.pos());
     CHECK_EQU(i, string_stream.pos());
@@ skipping 655 matching lines @@
   i::Isolate* isolate = CcTest::i_isolate();
   i::Factory* factory = isolate->factory();
 
   uintptr_t stack_limit = isolate->stack_guard()->real_climit();
 
   // Preparse the data.
   i::CompleteParserRecorder log;
   {
     i::Scanner scanner(isolate->unicode_cache());
     i::GenericStringUtf16CharacterStream stream(source, 0, source->length());
-    i::PreParser preparser(&scanner, &log, stack_limit);
+    i::PreParser preparser(&scanner, &log, stack_limit, NULL);
     SetParserFlags(&preparser, flags);
     scanner.Initialize(&stream);
     i::PreParser::PreParseResult result = preparser.PreParseProgram();
     CHECK_EQ(i::PreParser::kPreParseSuccess, result);
   }
   i::ScriptData data(log.ExtractData());
 
   // Parse the data
   i::FunctionLiteral* function;
   {
@@ skipping 1240 matching lines @@
   RunParserSyncTest(assignment_context_data, bad_statement_data_common, kError);
   RunParserSyncTest(assignment_context_data, bad_statement_data_for_assignment,
                     kError);
 
   RunParserSyncTest(prefix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(prefix_context_data, bad_statement_data_common, kError);
 
   RunParserSyncTest(postfix_context_data, good_statement_data, kSuccess);
   RunParserSyncTest(postfix_context_data, bad_statement_data_common, kError);
 }
+
+
+TEST(ParallelParsing) {
+  // Make lazy parsing and parallel parsing work for short scripts.
+  i::FLAG_min_preparse_length = 0;
+  i::FLAG_min_parallel_parse_length = 0;
+
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope handles(isolate);
+  v8::Local<v8::Context> context = v8::Context::New(isolate);
+  v8::Context::Scope context_scope(context);
+  int marker;
+  CcTest::i_isolate()->stack_guard()->SetStackLimit(
+      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
+
+  const char* code =
+      "var outside_var = 8;\n"
+      "function this_is_lazy() { return 5 + outside_var; }\n"
+      "(function not_lazy() { return this_is_lazy(); })()";
+  v8::ScriptCompiler::Source source(v8::String::NewExternal(
+      isolate, new ScriptResource(code, i::StrLength(code))));
+  v8::TryCatch try_catch;
+  v8::Handle<v8::Script> script = v8::ScriptCompiler::Compile(
+      isolate, &source, v8::ScriptCompiler::kProduceDataToCache);
+  CHECK(!script.IsEmpty());
+  CHECK(!try_catch.HasCaught());
+  v8::Local<v8::Value> result = script->Run();
+  CHECK(result->IsInt32());
+  CHECK_EQ(13, result->Int32Value());
+}
+
+
+TEST(ParallelParsingErrorInLazyFunction) {
+  // Make lazy parsing and parallel parsing work for short scripts.
+  i::FLAG_min_preparse_length = 0;
+  i::FLAG_min_parallel_parse_length = 0;
+
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope handles(isolate);
+  v8::Local<v8::Context> context = v8::Context::New(isolate);
+  v8::Context::Scope context_scope(context);
+  int marker;
+  CcTest::i_isolate()->stack_guard()->SetStackLimit(
+      reinterpret_cast<uintptr_t>(&marker) - 128 * 1024);
+
+  // Compile code which has error inside a lazy function. Check that we get an
+  // error.
+  const char* code =
+      "function this_is_lazy() { 1 2 3 error }";
+  v8::ScriptCompiler::Source source(v8::String::NewExternal(
+      isolate, new ScriptResource(code, i::StrLength(code))));
+  v8::TryCatch try_catch;
+  v8::Handle<v8::Script> script = v8::ScriptCompiler::Compile(
+      isolate, &source, v8::ScriptCompiler::kProduceDataToCache);
+  CHECK(try_catch.HasCaught());
+  v8::String::Utf8Value exception(try_catch.Exception());
+  CHECK_EQ("SyntaxError: Unexpected number", *exception);
+  CHECK(script.IsEmpty());
+}