Experimental code to detect transitive closure of parser code which causes new-space allocations

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 114 matching lines @@
 };
 
 
 #define TRACE_PARSER(s)                                                        \
   TraceParser __p__(this->TokenPos(), this->script_, &this->trace_indent_, s)
 
 #else  // not DEBUG
 #define TRACE_PARSER(s)
 #endif  // DEBUG
 
+EnterParserScope::EnterParserScope(Thread* thread)
+    : StackResource(thread), old_(thread->inside_parser_) {
+  thread->inside_parser_ = true;
+}
+EnterParserScope::~EnterParserScope() {
+  RELEASE_ASSERT(thread()->inside_parser_);
+  thread()->inside_parser_ = old_;
+}
+
+
+LeaveParserScope::LeaveParserScope(Thread* thread)
+    : StackResource(thread), old_(thread->inside_parser_) {
+  thread->inside_parser_ = false;
+}
+LeaveParserScope::~LeaveParserScope() {
+  RELEASE_ASSERT(!thread()->inside_parser_);
+  thread()->inside_parser_ = old_;
+}
+
 
 class BoolScope : public ValueObject {
  public:
   BoolScope(bool* addr, bool new_value) : _addr(addr), _saved_value(*addr) {
     *_addr = new_value;
   }
   ~BoolScope() { *_addr = _saved_value; }
 
  private:
   bool* _addr;
@@ skipping 305 matching lines @@
   }
 }
 
 
 // For parsing a compilation unit.
 Parser::Parser(const Script& script,
                const Library& library,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
-      allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
+      enter_parser_scope_(thread_),
+      allocation_space_(Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
@@ skipping 12 matching lines @@
   ASSERT(!library.IsNull());
 }
 
 
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
-      allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
+      enter_parser_scope_(thread_),
+      allocation_space_(Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
                        token_pos),
       token_kind_(Token::kILLEGAL),
       current_block_(NULL),
       is_top_level_(false),
       await_is_keyword_(false),
       current_member_(NULL),
       allow_function_literals_(true),
@@ skipping 5629 matching lines @@
       }
       return Object::null();
     }
     ReportError(token_pos, "no library handler registered");
   }
   // Block class finalization attempts when calling into the library
   // tag handler.
   I->BlockClassFinalization();
   Object& result = Object::Handle(Z);
   {
+    LeaveParserScope _(thread_);
     TransitionVMToNative transition(T);
     Api::Scope api_scope(T);
     Dart_Handle retval = handler(tag, Api::NewHandle(T, library_.raw()),
                                  Api::NewHandle(T, url.raw()));
     result = Api::UnwrapHandle(retval);
   }
   I->UnblockClassFinalization();
   if (result.IsError()) {
     // In case of an error we append an explanatory error message to the
     // error obtained from the library tag handler.
@@ skipping 86 matching lines @@
         continue;
       }
       // Check if this conditional line overrides the default import.
       const String& key = String::Handle(String::ConcatAll(
           Array::Handle(Array::MakeArray(pieces)), allocation_space_));
       const String& value =
           (valueNode == NULL)
               ? Symbols::True()
               : String::Cast(valueNode->AsLiteralNode()->literal());
       // Call the embedder to supply us with the environment.
-      const String& env_value =
-          String::Handle(Api::GetEnvironmentValue(T, key));
+      String& env_value = String::Handle();
+      {
+        LeaveParserScope _(thread_);
+        env_value = Api::GetEnvironmentValue(T, key);
+      }
       if (!env_value.IsNull() && env_value.Equals(value)) {
         condition_triggered = true;
         url_literal = conditional_url_literal;
       }
     }
   }
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   if (url.Length() == 0) {
@@ skipping 6461 matching lines @@
       NoOOBMessageScope no_msg_scope(thread());
       field.SetStaticValue(Object::transition_sentinel());
       const int kTypeArgsLen = 0;   // No type argument vector.
       const int kNumArguments = 0;  // No arguments.
       const Function& func = Function::Handle(
           Z, Resolver::ResolveStatic(field_owner, getter_name, kTypeArgsLen,
                                      kNumArguments, Object::empty_array()));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
       Object& const_value = Object::Handle(Z);
-      const_value = DartEntry::InvokeFunction(func, Object::empty_array());
+      {
+        LeaveParserScope _(thread_);
+        const_value = DartEntry::InvokeFunction(func, Object::empty_array());
+      }
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
           current_function().SetIsOptimizable(false);
           field.SetStaticValue(Object::null_instance());
           // It is a compile-time error if evaluation of a compile-time constant
           // would raise an exception.
@@ skipping 59 matching lines @@
   }
   for (int i = 0; i < arguments->length(); i++) {
     AstNode* arg = arguments->NodeAt(i);
     // Arguments have been evaluated to a literal value already.
     ASSERT(arg->IsLiteralNode());
     arg_values.SetAt((i + kNumExtraArgs), arg->AsLiteralNode()->literal());
   }
   const Array& args_descriptor =
       Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, num_arguments,
                                                 arguments->names()));
-  const Object& result = Object::Handle(
-      Z, DartEntry::InvokeFunction(constructor, arg_values, args_descriptor));
+
+  Object& result = Object::Handle(Z);
+  {
+    LeaveParserScope _(thread_);
+    result =
+        DartEntry::InvokeFunction(constructor, arg_values, args_descriptor);
+  }
+
   if (result.IsError()) {
     // An exception may not occur in every parse attempt, i.e., the
     // generated AST is not deterministic. Therefore mark the function as
     // not optimizable.
     current_function().SetIsOptimizable(false);
     if (result.IsUnhandledException()) {
       return result.raw();
     } else {
       thread()->long_jump_base()->Jump(1, Error::Cast(result));
       UNREACHABLE();
@@ skipping 1581 matching lines @@
     ASSERT(values[i]->IsLiteralNode());
     value_arr.SetAt(i, values[i]->AsLiteralNode()->literal());
   }
 
   // Build argument array to pass to the interpolation function.
   const Array& interpolate_arg = Array::Handle(Z, Array::New(1, Heap::kOld));
   interpolate_arg.SetAt(0, value_arr);
 
   // Call interpolation function.
   Object& result = Object::Handle(Z);
-  result = DartEntry::InvokeFunction(func, interpolate_arg);
+  {
+    LeaveParserScope _(thread_);
+    result = DartEntry::InvokeFunction(func, interpolate_arg);
+  }
   if (result.IsUnhandledException()) {
     ReportError("%s", Error::Cast(result).ToErrorCString());
   }
   String& concatenated = String::ZoneHandle(Z);
   concatenated ^= result.raw();
   concatenated = Symbols::New(T, concatenated);
   return concatenated;
 }
 
 
@@ skipping 346 matching lines @@
       return value;
     }
     ReturnNode* ret = new (Z) ReturnNode(expr_pos, expr);
     // Compile time constant expressions cannot reference anything from a
     // local scope.
     LocalScope* empty_scope = new (Z) LocalScope(NULL, 0, 0);
     SequenceNode* seq = new (Z) SequenceNode(expr_pos, empty_scope);
     seq->Add(ret);
 
     INC_STAT(thread_, num_execute_const, 1);
-    Object& result = Object::Handle(Z, Compiler::ExecuteOnce(seq));
+    Object& result = Object::Handle(Z);
+    {
+      LeaveParserScope _(thread_);
+      result = Compiler::ExecuteOnce(seq);
+    }
     if (result.IsError()) {
       ReportErrors(Error::Cast(result), script_, expr_pos,
                    "error evaluating constant expression");
     }
     ASSERT(result.IsInstance() || result.IsNull());
     value ^= result.raw();
     value = TryCanonicalize(value, expr_pos);
     CacheConstantValue(expr_pos, value);
     return value;
   }
@@ skipping 461 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME