Support lazy parsing of inner functions

src/parser.cc

 // Copyright 2012 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 "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
 #include "src/char-predicates-inl.h"
 #include "src/codegen.h"
 #include "src/compiler.h"
 #include "src/messages.h"
 #include "src/parser.h"
 #include "src/preparser.h"
 #include "src/runtime/runtime.h"
 #include "src/scanner-character-streams.h"
 #include "src/scopeinfo.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
 
+
+int FunctionEntry::Size() {
+  if (backing_.is_empty()) return 0;
+  int result = kSize;
+  for (int i = 0; i < identifier_count(); i++) {
+    result += 1;  // is_one_byte
+    CHECK(result < backing_.length());
+    const int byte_length = backing_[result];
+    const int word_length =
+        1 + (((byte_length * sizeof(unsigned char)) - 1) / sizeof(unsigned));
+    result += 1;  // length
+    result += word_length;
+  }
+  CHECK(result <= backing_.length());
+  return result;
+}
+
+
+const AstRawString* FunctionEntry::IdentifierIterator::Next(
+    AstValueFactory* ast_value_factory) {
+  // FunctionEntry::size() is always called when an IdentifierIterator is
+  // constructed (by FunctionEntry::Identifiers), and FunctionEntry::size()
+  // CHECKs that the identifiers don't run past the end of backing_ so we don't
+  // have to CHECK that here.
+  DCHECK(!AtEnd());
+  const bool is_one_byte = static_cast<bool>(backing_.first());
+  backing_ += 1;
+  const int length = backing_.first();
+  backing_ += 1;
+  if (is_one_byte) {
+    Vector<const uint8_t> data = Vector<const uint8_t>::cast(backing_);
+    data.Truncate(length);
+    const int word_length =
+        1 + (((length * sizeof(uint8_t)) - 1) / sizeof(unsigned));
+    backing_ += word_length;
+    return ast_value_factory->GetOneByteString(data);
+  } else {
+    Vector<const uint16_t> data = Vector<const uint16_t>::cast(backing_);
+    data.Truncate(length);
+    const int word_length =
+        1 + (((length * sizeof(uint16_t)) - 1) / sizeof(unsigned));
+    backing_ += word_length;
+    return ast_value_factory->GetTwoByteString(data);
+  }
+}
+
+
 RegExpBuilder::RegExpBuilder(Zone* zone)
     : zone_(zone),
       pending_empty_(false),
       characters_(NULL),
       terms_(),
       alternatives_()
 #ifdef DEBUG
     , last_added_(ADD_NONE)
 #endif
   {}
@@ skipping 145 matching lines @@
       new(zone()) RegExpQuantifier(min, max, quantifier_type, atom), zone());
   LAST(ADD_TERM);
 }
 
 
 FunctionEntry ParseData::GetFunctionEntry(int start) {
   // The current pre-data entry must be a FunctionEntry with the given
   // start position.
   if ((function_index_ + FunctionEntry::kSize <= Length()) &&
       (static_cast<int>(Data()[function_index_]) == start)) {
-    int index = function_index_;
-    function_index_ += FunctionEntry::kSize;
-    Vector<unsigned> subvector(&(Data()[index]), FunctionEntry::kSize);
-    return FunctionEntry(subvector);
+    int remaining_length = Length() - function_index_;
+    Vector<unsigned> subvector(&(Data()[function_index_]), remaining_length);
+    FunctionEntry entry(subvector);
+    int entry_size = entry.Size();
+    CHECK(entry_size <= remaining_length);
+    function_index_ += entry_size;
+    return entry;
   }
   return FunctionEntry();
 }
 
 
 int ParseData::FunctionCount() {
-  int functions_size = FunctionsSize();
-  if (functions_size < 0) return 0;
-  if (functions_size % FunctionEntry::kSize != 0) return 0;
-  return functions_size / FunctionEntry::kSize;
+  int function_count = 0;
+  int function_index = PreparseDataConstants::kHeaderSize;
+  while (function_index < Length()) {
+    function_count += 1;
+    Vector<unsigned> subvector(&(Data()[function_index]),
+                               Length() - function_index);
+    FunctionEntry entry(subvector);
+    function_index += entry.Size();
+  }
+  return function_count;
 }
 
 
 bool ParseData::IsSane() {
   // Check that the header data is valid and doesn't specify
   // point to positions outside the store.
   int data_length = Length();
   if (data_length < PreparseDataConstants::kHeaderSize) return false;
   if (Magic() != PreparseDataConstants::kMagicNumber) return false;
   if (Version() != PreparseDataConstants::kCurrentVersion) return false;
   if (HasError()) return false;
   // Check that the space allocated for function entries is sane.
   int functions_size = FunctionsSize();
   if (functions_size < 0) return false;
-  if (functions_size % FunctionEntry::kSize != 0) return false;
   // Check that the total size has room for header and function entries.
   int minimum_size =
       PreparseDataConstants::kHeaderSize + functions_size;
   if (data_length < minimum_size) return false;
   return true;
 }
 
 
 void ParseData::Initialize() {
   // Prepares state for use.
@@ skipping 692 matching lines @@
     }
   }
 
   // Make sure the target stack is empty.
   DCHECK(target_stack_ == NULL);
 
   return result;
 }
 
 
+// This method is invoked by the runtime to re-parse the source of a lazily
+// compiled function when that function gets called.
 FunctionLiteral* Parser::ParseLazy() {
   // It's OK to use the counters here, since this function is only called in
   // the main thread.
   HistogramTimerScope timer_scope(isolate()->counters()->parse_lazy());
   Handle<String> source(String::cast(script()->source()));
   isolate()->counters()->total_parse_size()->Increment(source->length());
   base::ElapsedTimer timer;
   if (FLAG_trace_parse) {
     timer.Start();
   }
@@ skipping 2659 matching lines @@
     // lazy compilation are:
     // - It must not have been prohibited by the caller to Parse (some callers
     //   need a full AST).
     // - The outer scope must allow lazy compilation of inner functions.
     // - The function mustn't be a function expression with an open parenthesis
     //   before; we consider that a hint that the function will be called
     //   immediately, and it would be a waste of time to make it lazily
     //   compiled.
     // These are all things we can know at this point, without looking at the
     // function itself.
-
-    // In addition, we need to distinguish between these cases:
-    // (function foo() {
-    //   bar = function() { return 1; }
-    //  })();
-    // and
-    // (function foo() {
-    //   var a = 1;
-    //   bar = function() { return a; }
-    //  })();
-
-    // Now foo will be parsed eagerly and compiled eagerly (optimization: assume
-    // parenthesis before the function means that it will be called
-    // immediately). The inner function *must* be parsed eagerly to resolve the
-    // possible reference to the variable in foo's scope. However, it's possible
-    // that it will be compiled lazily.
-
-    // To make this additional case work, both Parser and PreParser implement a
-    // logic where only top-level functions will be parsed lazily.
-    bool is_lazily_parsed = (mode() == PARSE_LAZILY &&
-                             scope_->AllowsLazyCompilation() &&
-                             !parenthesized_function_);
+    bool is_lazily_parsed =
+        (mode() != PARSE_EAGERLY && scope_->AllowsLazyCompilation() &&
+         !parenthesized_function_);
     parenthesized_function_ = false;  // The bit was set for this function only.
 
     if (is_lazily_parsed) {
       SkipLazyFunctionBody(function_name, &materialized_literal_count,
                            &expected_property_count, CHECK_OK);
     } else {
       body = ParseEagerFunctionBody(function_name, pos, fvar, fvar_init_op,
                                     is_generator, CHECK_OK);
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
@@ skipping 67 matching lines @@
 
     scope_->set_end_position(entry.end_pos());
     Expect(Token::RBRACE, ok);
     if (!*ok) {
       return;
     }
     total_preparse_skipped_ += scope_->end_position() - function_block_pos;
     *materialized_literal_count = entry.literal_count();
     *expected_property_count = entry.property_count();
     scope_->SetStrictMode(entry.strict_mode());
+    if (entry.calls_eval()) {
+      // If there is a direct call to eval (ES5 10.4.2(2) / 15.1.2.1.1) then
+      // every variable gets allocated and there's little point in keeping track
+      // of which variables are accessed by nested functions.
+      scope_->DeclarationScope()->RecordEvalCall();
+    } else {
+      FunctionEntry::IdentifierIterator it = entry.Identifiers();
+      while (!it.AtEnd()) {
+        ExpressionFromIdentifier(it.Next(ast_value_factory()),
+                                 RelocInfo::kNoPosition, scope_, factory());
+      }
+    }
   } else {
     // With no cached data, we partially parse the function, without building an
     // AST. This gathers the data needed to build a lazy function.
     SingletonLogger logger;
     PreParser::PreParseResult result =
         ParseLazyFunctionBodyWithPreParser(&logger);
     if (result == PreParser::kPreParseStackOverflow) {
       // Propagate stack overflow.
       set_stack_overflow();
       *ok = false;
       return;
     }
     if (logger.has_error()) {
       ParserTraits::ReportMessageAt(
           Scanner::Location(logger.start(), logger.end()),
           logger.message(), logger.argument_opt(), logger.is_reference_error());
       *ok = false;
       return;
     }
     scope_->set_end_position(logger.end());
     Expect(Token::RBRACE, ok);
     if (!*ok) {
       return;
     }
+
+    if (logger.calls_eval()) {
+      scope_->DeclarationScope()->RecordEvalCall();
+      if (compile_options() == ScriptCompiler::kProduceParserCache) {
+        DCHECK(log_);
+        log_->LogEvalCall();
+      }
+    } else {
+      SingletonLogger::IdentifierIterator it = logger.IdentifiersStart();
+      for (const AstRawString* identifier = it.Next(); identifier != NULL;
+           identifier = it.Next()) {
+        // position doesn't matter here, we're only creating the expression
+        // so we can track usage of variables
+        ExpressionFromIdentifier(identifier, RelocInfo::kNoPosition, scope_,
+                                 factory());
+        if (compile_options() == ScriptCompiler::kProduceParserCache) {
+          DCHECK(log_);
+          log_->LogIdentifier(identifier);
+        }
+      }
+    }
+
     total_preparse_skipped_ += scope_->end_position() - function_block_pos;
     *materialized_literal_count = logger.literals();
     *expected_property_count = logger.properties();
     scope_->SetStrictMode(logger.strict_mode());
     if (compile_options() == ScriptCompiler::kProduceParserCache) {
       DCHECK(log_);
       // Position right after terminal '}'.
       int body_end = scanner()->location().end_pos;
       log_->LogFunction(function_block_pos, body_end,
                         *materialized_literal_count,
                         *expected_property_count,
                         scope_->strict_mode());
     }
   }
 }
 
 
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos, Variable* fvar,
     Token::Value fvar_init_op, bool is_generator, bool* ok) {
-  // Everything inside an eagerly parsed function will be parsed eagerly
-  // (see comment above).
-  ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
+  // We can lazily parse functions enclosed in eagerly parsed functions but we
+  // have to keep track of what variables the inner functions access - or if the
+  // the inner function calls eval (in which case we have to assume every
+  // variable might be accessed inside the eval).
+  Mode mode =
+      (mode_ == PARSE_EAGERLY) ? PARSE_EAGERLY : PARSE_INNER_FUNCTION_LAZILY;
+  ParsingModeScope parsing_mode(this, mode);
+
   ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8, zone());
   if (fvar != NULL) {
     VariableProxy* fproxy = scope_->NewUnresolved(
         factory(), function_name, Interface::NewConst());
     fproxy->BindTo(fvar);
     body->Add(factory()->NewExpressionStatement(
         factory()->NewAssignment(fvar_init_op,
                                  fproxy,
                                  factory()->NewThisFunction(pos),
                                  RelocInfo::kNoPosition),
@@ skipping 43 matching lines @@
 PreParser::PreParseResult Parser::ParseLazyFunctionBodyWithPreParser(
     SingletonLogger* logger) {
   // This function may be called on a background thread too; record only the
   // main thread preparse times.
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Start();
   }
   DCHECK_EQ(Token::LBRACE, scanner()->current_token());
 
   if (reusable_preparser_ == NULL) {
-    reusable_preparser_ = new PreParser(&scanner_, NULL, stack_limit_);
+    reusable_preparser_ = new PreParser(&scanner_, NULL, ast_value_factory(),
+                                        zone(), stack_limit_);
     reusable_preparser_->set_allow_harmony_scoping(allow_harmony_scoping());
     reusable_preparser_->set_allow_modules(allow_modules());
     reusable_preparser_->set_allow_natives_syntax(allow_natives_syntax());
     reusable_preparser_->set_allow_lazy(true);
     reusable_preparser_->set_allow_arrow_functions(allow_arrow_functions());
     reusable_preparser_->set_allow_harmony_numeric_literals(
         allow_harmony_numeric_literals());
     reusable_preparser_->set_allow_classes(allow_classes());
     reusable_preparser_->set_allow_harmony_object_literals(
         allow_harmony_object_literals());
   }
-  PreParser::PreParseResult result =
-      reusable_preparser_->PreParseLazyFunction(strict_mode(),
-                                                is_generator(),
-                                                logger);
+  PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction(
+      strict_mode(), is_generator(), mode_ == PARSE_INNER_FUNCTION_LAZILY,
+      logger);
   if (pre_parse_timer_ != NULL) {
     pre_parse_timer_->Stop();
   }
   return result;
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
@@ skipping 1094 matching lines @@
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
 }
 } }  // namespace v8::internal