Relax inlining limits for simple leaf functions.

src/parser.cc

 // Copyright 2011 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 638 matching lines @@
   FunctionLiteral* result = NULL;
   { Scope* scope = NewScope(top_scope_, GLOBAL_SCOPE);
     info->SetGlobalScope(scope);
     if (!info->is_global()) {
       scope = Scope::DeserializeScopeChain(*info->calling_context(), scope);
       scope = NewScope(scope, EVAL_SCOPE);
     }
     scope->set_start_position(0);
     scope->set_end_position(source->length());
     FunctionState function_state(this, scope, isolate());
+    int ast_nodes_before = isolate()->ast_node_count();

[Kevin Millikin (Chromium), 2011/11/28 12:11:59]

It seems overly complicated to use the global counter for all AST nodes
constructed for this isolate, when what we're interested in is nodes per
function.

I suggest saving the old value and zeroing it here, then restoring the old
value.

Further, you should do it in the FunctionState constructor (the you won't miss
any cases, like the one in Parser::ParseLazy (or do you intend to skip that
one---if so it's pretty subtle)).

[ulan, 2011/11/29 14:06:52]

Done.

+    int non_primitive_ast_nodes_before =
+        isolate()->non_primitive_ast_node_count();

[Kevin Millikin (Chromium), 2011/11/28 12:11:59]

There's no need to count them is there?  If not, it's simpler to just have a
sticky flag.  Save the current value and clear it here (actually in the
FunctionState constructor) and restore its value in the FunctionState
destructor.

[ulan, 2011/11/29 14:06:52]

Done.

     top_scope_->SetStrictModeFlag(info->strict_mode_flag());
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16);
     bool ok = true;
     int beg_loc = scanner().location().beg_pos;
     ParseSourceElements(body, Token::EOS, &ok);
     if (ok && top_scope_->is_strict_mode()) {
       CheckOctalLiteral(beg_loc, scanner().location().end_pos, &ok);
     }
 
     if (ok && harmony_scoping_) {
       CheckConflictingVarDeclarations(scope, &ok);
     }
 
+    int ast_nodes_added = isolate()->ast_node_count() - ast_nodes_before + 1;
+    bool is_primitive = (isolate()->non_primitive_ast_node_count() -
+                         non_primitive_ast_nodes_before == 0);
+
     if (ok) {
       result = new(zone()) FunctionLiteral(
           isolate(),
           no_name,
           top_scope_,
           body,
           function_state.materialized_literal_count(),
           function_state.expected_property_count(),
           function_state.handler_count(),
           function_state.only_simple_this_property_assignments(),
           function_state.this_property_assignments(),
           0,
           FunctionLiteral::ANONYMOUS_EXPRESSION,
-          false);  // Does not have duplicate parameters.
+          false,  // Does not have duplicate parameters.
+          ast_nodes_added,
+          is_primitive);
     } else if (stack_overflow_) {
       isolate()->StackOverflow();
     }
   }
 
   // Make sure the target stack is empty.
   ASSERT(target_stack_ == NULL);
 
   // If there was a syntax error we have to get rid of the AST
   // and it is not safe to do so before the scope has been deleted.
@@ skipping 1480 matching lines @@
   Expect(Token::RPAREN, CHECK_OK);
 
   top_scope_->DeclarationScope()->RecordWithStatement();
   Scope* with_scope = NewScope(top_scope_, WITH_SCOPE);
   Statement* stmt;
   { BlockState block_state(this, with_scope);
     with_scope->set_start_position(scanner().peek_location().beg_pos);
     stmt = ParseStatement(labels, CHECK_OK);
     with_scope->set_end_position(scanner().location().end_pos);
   }
-  return new(zone()) WithStatement(expr, stmt);
+  return new(zone()) WithStatement(isolate(), expr, stmt);
 }
 
 
 CaseClause* Parser::ParseCaseClause(bool* default_seen_ptr, bool* ok) {
   // CaseClause ::
   //   'case' Expression ':' Statement*
   //   'default' ':' Statement*
 
   Expression* label = NULL;  // NULL expression indicates default case
   if (peek() == Token::CASE) {
@@ skipping 145 matching lines @@
 
   // Simplify the AST nodes by converting:
   //   'try B0 catch B1 finally B2'
   // to:
   //   'try { try B0 catch B1 } finally B2'
 
   if (catch_block != NULL && finally_block != NULL) {
     // If we have both, create an inner try/catch.
     ASSERT(catch_scope != NULL && catch_variable != NULL);
     int index = current_function_state_->NextHandlerIndex();
-    TryCatchStatement* statement = new(zone()) TryCatchStatement(index,
+    TryCatchStatement* statement = new(zone()) TryCatchStatement(isolate(),
+                                                                 index,
                                                                  try_block,
                                                                  catch_scope,
                                                                  catch_variable,
                                                                  catch_block);
     statement->set_escaping_targets(try_collector.targets());
     try_block = new(zone()) Block(isolate(), NULL, 1, false);
     try_block->AddStatement(statement);
     catch_block = NULL;  // Clear to indicate it's been handled.
   }
 
   TryStatement* result = NULL;
   if (catch_block != NULL) {
     ASSERT(finally_block == NULL);
     ASSERT(catch_scope != NULL && catch_variable != NULL);
     int index = current_function_state_->NextHandlerIndex();
-    result = new(zone()) TryCatchStatement(index,
+    result = new(zone()) TryCatchStatement(isolate(),
+                                           index,
                                            try_block,
                                            catch_scope,
                                            catch_variable,
                                            catch_block);
   } else {
     ASSERT(finally_block != NULL);
     int index = current_function_state_->NextHandlerIndex();
-    result = new(zone()) TryFinallyStatement(index,
+    result = new(zone()) TryFinallyStatement(isolate(),
+                                             index,
                                              try_block,
                                              finally_block);
     // Combine the jump targets of the try block and the possible catch block.
     try_collector.targets()->AddAll(*catch_collector.targets());
   }
 
   result->set_escaping_targets(try_collector.targets());
   return result;
 }
 
@@ skipping 1544 matching lines @@
   // Function declarations are function scoped in normal mode, so they are
   // hoisted. In harmony block scoping mode they are block scoped, so they
   // are not hoisted.
   Scope* scope = (type == FunctionLiteral::DECLARATION && !harmony_scoping_)
       ? NewScope(top_scope_->DeclarationScope(), FUNCTION_SCOPE)
       : NewScope(top_scope_, FUNCTION_SCOPE);
   ZoneList<Statement*>* body = NULL;
   int materialized_literal_count;
   int expected_property_count;
   int handler_count = 0;
+  int ast_node_count_before = isolate_->ast_node_count();
+  int non_primitive_ast_node_count_before =
+      isolate_->non_primitive_ast_node_count();
   bool only_simple_this_property_assignments;
   Handle<FixedArray> this_property_assignments;
   bool has_duplicate_parameters = false;
   // Parse function body.
   { FunctionState function_state(this, scope, isolate());
     top_scope_->SetScopeName(function_name);
 
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
@@ skipping 161 matching lines @@
       CheckOctalLiteral(scope->start_position(),
                         scope->end_position(),
                         CHECK_OK);
     }
   }
 
   if (harmony_scoping_) {
     CheckConflictingVarDeclarations(scope, CHECK_OK);
   }
 
+  int ast_nodes_added = isolate_->ast_node_count() - ast_node_count_before + 1;
+  bool is_primitive = (isolate_->non_primitive_ast_node_count() -
+                       non_primitive_ast_node_count_before == 0);
+
   FunctionLiteral* function_literal =
       new(zone()) FunctionLiteral(isolate(),
                                   function_name,
                                   scope,
                                   body,
                                   materialized_literal_count,
                                   expected_property_count,
                                   handler_count,
                                   only_simple_this_property_assignments,
                                   this_property_assignments,
                                   num_parameters,
                                   type,
-                                  has_duplicate_parameters);
+                                  has_duplicate_parameters,
+                                  ast_nodes_added,
+                                  is_primitive);
   function_literal->set_function_token_position(function_token_position);
 
   if (fni_ != NULL && should_infer_name) fni_->AddFunction(function_literal);
   return function_literal;
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
@@ skipping 1314 matching lines @@
       ASSERT(info->isolate()->has_pending_exception());
     } else {
       result = parser.ParseProgram(info);
     }
   }
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal