Relax inlining limits for simple leaf functions (second version).

src/ast.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 153 matching lines @@
 
 int FunctionLiteral::end_position() const {
   return scope()->end_position();
 }
 
 
 StrictModeFlag FunctionLiteral::strict_mode_flag() const {
   return scope()->strict_mode_flag();
 }
 
+void FunctionLiteral::ComputeAstNodeCountAndInlineableFlags() {
+  is_function_inlineable_ = false;
+  is_function_primitive_ = true;
+  // All declarations must be inlineable.
+  ZoneList<Declaration*>* decls = scope()->declarations();
+  int decl_count = decls->length();
+  for (int i = 0; i < decl_count; ++i) {
+    if (!decls->at(i)->IsInlineable(this)) {
+      is_function_primitive_ = false;
+      return;
+    }
+  }
+  // All statements in the body must be inlineable.
+  for (int i = 0, count = body()->length(); i < count; ++i) {
+    if (!body()->at(i)->IsInlineable(this)) {
+      is_function_primitive_ = false;
+      return;
+    }
+  }
+  is_function_inlineable_ = true;
+}
+
 
 ObjectLiteral::Property::Property(Literal* key, Expression* value) {
   emit_store_ = true;
   key_ = key;
   value_ = value;
   Object* k = *key->handle();
   if (k->IsSymbol() && HEAP->Proto_symbol()->Equals(String::cast(k))) {
     kind_ = PROTOTYPE;
   } else if (value_->AsMaterializedLiteral() != NULL) {
     kind_ = MATERIALIZED_LITERAL;
@@ skipping 228 matching lines @@
 
 bool CompareOperation::IsLiteralCompareNull(Expression** expr) {
   return MatchLiteralCompareNull(left_, op_, right_, expr) ||
       MatchLiteralCompareNull(right_, op_, left_, expr);
 }
 
 
 // ----------------------------------------------------------------------------
 // Inlining support
 
-bool Declaration::IsInlineable() const {
-  return proxy()->var()->IsStackAllocated() && fun() == NULL;
-}
-
-
-bool TargetCollector::IsInlineable() const {
+bool Declaration::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return (proxy()->var()->IsStackAllocated() && fun() == NULL);
+}
+
+
+bool TargetCollector::IsInlineable(FunctionLiteral* function) const {
   UNREACHABLE();
   return false;
 }
 
 
-bool ForInStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool WithStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool SwitchStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool TryStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool TryCatchStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool TryFinallyStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool DebuggerStatement::IsInlineable() const {
-  return false;
-}
-
-
-bool Throw::IsInlineable() const {
-  return exception()->IsInlineable();
-}
-
-
-bool MaterializedLiteral::IsInlineable() const {
+bool ForInStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool WithStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool SwitchStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool TryStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool TryCatchStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool TryFinallyStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool DebuggerStatement::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool Throw::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return exception()->IsInlineable(function);
+}
+
+
+bool MaterializedLiteral::IsInlineable(FunctionLiteral* function) const {
   // TODO(1322): Allow materialized literals.
   return false;
 }
 
 
-bool FunctionLiteral::IsInlineable() const {
+bool FunctionLiteral::IsInlineable(FunctionLiteral* function) const {
   // TODO(1322): Allow materialized literals.
   return false;
 }
 
 
-bool ThisFunction::IsInlineable() const {
-  return true;
-}
-
-
-bool SharedFunctionInfoLiteral::IsInlineable() const {
-  return false;
-}
-
-
-bool ForStatement::IsInlineable() const {
-  return (init() == NULL || init()->IsInlineable())
-      && (cond() == NULL || cond()->IsInlineable())
-      && (next() == NULL || next()->IsInlineable())
-      && body()->IsInlineable();
-}
-
-
-bool WhileStatement::IsInlineable() const {
-  return cond()->IsInlineable()
-      && body()->IsInlineable();
-}
-
-
-bool DoWhileStatement::IsInlineable() const {
-  return cond()->IsInlineable()
-      && body()->IsInlineable();
-}
-
-
-bool ContinueStatement::IsInlineable() const {
-  return true;
-}
-
-
-bool BreakStatement::IsInlineable() const {
-  return true;
-}
-
-
-bool EmptyStatement::IsInlineable() const {
-  return true;
-}
-
-
-bool Literal::IsInlineable() const {
-  return true;
-}
-
-
-bool Block::IsInlineable() const {
+bool ThisFunction::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return true;
+}
+
+
+bool SharedFunctionInfoLiteral::IsInlineable(FunctionLiteral* function) const {
+  return false;
+}
+
+
+bool ForStatement::IsInlineable(FunctionLiteral* function) const {
+  function->mark_as_not_primitive();
+  function->increment_ast_node_count();
+  return (init() == NULL || init()->IsInlineable(function))
+      && (cond() == NULL || cond()->IsInlineable(function))
+      && (next() == NULL || next()->IsInlineable(function))
+      && body()->IsInlineable(function);
+}
+
+
+bool WhileStatement::IsInlineable(FunctionLiteral* function) const {
+  function->mark_as_not_primitive();
+  function->increment_ast_node_count();
+  return cond()->IsInlineable(function)
+      && body()->IsInlineable(function);
+}
+
+
+bool DoWhileStatement::IsInlineable(FunctionLiteral* function) const {
+  function->mark_as_not_primitive();
+  function->increment_ast_node_count();
+  return cond()->IsInlineable(function)
+      && body()->IsInlineable(function);
+}
+
+
+bool ContinueStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return true;
+}
+
+
+bool BreakStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return true;
+}
+
+
+bool EmptyStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return true;
+}
+
+
+bool Literal::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return true;
+}
+
+
+bool Block::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
   const int count = statements_.length();
   for (int i = 0; i < count; ++i) {
-    if (!statements_[i]->IsInlineable()) return false;
+    if (!statements_[i]->IsInlineable(function)) return false;
   }
   return true;
 }
 
 
-bool ExpressionStatement::IsInlineable() const {
-  return expression()->IsInlineable();
-}
-
-
-bool IfStatement::IsInlineable() const {
-  return condition()->IsInlineable()
-      && then_statement()->IsInlineable()
-      && else_statement()->IsInlineable();
-}
-
-
-bool ReturnStatement::IsInlineable() const {
-  return expression()->IsInlineable();
-}
-
-
-bool Conditional::IsInlineable() const {
-  return condition()->IsInlineable() && then_expression()->IsInlineable() &&
-      else_expression()->IsInlineable();
-}
-
-
-bool VariableProxy::IsInlineable() const {
+bool ExpressionStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return expression()->IsInlineable(function);
+}
+
+
+bool IfStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return condition()->IsInlineable(function)
+      && then_statement()->IsInlineable(function)
+      && else_statement()->IsInlineable(function);
+}
+
+
+bool ReturnStatement::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return expression()->IsInlineable(function);
+}
+
+
+bool Conditional::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return condition()->IsInlineable(function)
+      && then_expression()->IsInlineable(function)
+      && else_expression()->IsInlineable(function);
+}
+
+
+bool VariableProxy::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
   return var()->IsUnallocated()
       || var()->IsStackAllocated()
       || var()->IsContextSlot();
 }
 
 
-bool Assignment::IsInlineable() const {
-  return target()->IsInlineable() && value()->IsInlineable();
-}
-
-
-bool Property::IsInlineable() const {
-  return obj()->IsInlineable() && key()->IsInlineable();
-}
-
-
-bool Call::IsInlineable() const {
-  if (!expression()->IsInlineable()) return false;
+bool Assignment::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return target()->IsInlineable(function)
+      && value()->IsInlineable(function);
+}
+
+
+bool Property::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return obj()->IsInlineable(function)
+      && key()->IsInlineable(function);
+}
+
+
+bool Call::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  function->mark_as_not_primitive();
+  if (!expression()->IsInlineable(function)) return false;
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
-    if (!arguments()->at(i)->IsInlineable()) return false;
+    if (!arguments()->at(i)->IsInlineable(function)) {
+      return false;
+    }
   }
   return true;
 }
 
 
-bool CallNew::IsInlineable() const {
-  if (!expression()->IsInlineable()) return false;
+bool CallNew::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  function->mark_as_not_primitive();
+  if (!expression()->IsInlineable(function)) return false;
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
-    if (!arguments()->at(i)->IsInlineable()) return false;
+    if (!arguments()->at(i)->IsInlineable(function)) {
+      return false;
+    }
   }
   return true;
 }
 
 
-bool CallRuntime::IsInlineable() const {
+bool CallRuntime::IsInlineable(FunctionLiteral* function_literal) const {
   // Don't try to inline JS runtime calls because we don't (currently) even
   // optimize them.
   if (is_jsruntime()) return false;
   // Don't inline the %_ArgumentsLength or %_Arguments because their
   // implementation will not work.  There is no stack frame to get them
   // from.
   if (function()->intrinsic_type == Runtime::INLINE &&
       (name()->IsEqualTo(CStrVector("_ArgumentsLength")) ||
        name()->IsEqualTo(CStrVector("_Arguments")))) {
     return false;
   }
+  function_literal->increment_ast_node_count();
+  function_literal->mark_as_not_primitive();
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
-    if (!arguments()->at(i)->IsInlineable()) return false;
+    if (!arguments()->at(i)->IsInlineable(function_literal)) {
+      return false;
+    }
   }
   return true;
 }
 
 
-bool UnaryOperation::IsInlineable() const {
-  return expression()->IsInlineable();
+bool UnaryOperation::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return expression()->IsInlineable(function);
 }
 
 
-bool BinaryOperation::IsInlineable() const {
-  return left()->IsInlineable() && right()->IsInlineable();
+bool BinaryOperation::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return left()->IsInlineable(function)
+      && right()->IsInlineable(function);
 }
 
 
-bool CompareOperation::IsInlineable() const {
-  return left()->IsInlineable() && right()->IsInlineable();
+bool CompareOperation::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return left()->IsInlineable(function)
+      && right()->IsInlineable(function);
 }
 
 
-bool CountOperation::IsInlineable() const {
-  return expression()->IsInlineable();
+bool CountOperation::IsInlineable(FunctionLiteral* function) const {
+  function->increment_ast_node_count();
+  return expression()->IsInlineable(function);
 }
 
 
 // ----------------------------------------------------------------------------
 // Recording of type feedback
 
 void Property::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
   // Record type feedback from the oracle in the AST.
   is_monomorphic_ = oracle->LoadIsMonomorphicNormal(this);
   receiver_types_.Clear();
@@ skipping 557 matching lines @@
                        int pos)
     : label_(label),
       statements_(statements),
       position_(pos),
       compare_type_(NONE),
       compare_id_(AstNode::GetNextId(isolate)),
       entry_id_(AstNode::GetNextId(isolate)) {
 }
 
 } }  // namespace v8::internal