Collect AstNode type information

src/ast.cc

-// Copyright 2011 the V8 project authors. All rights reserved.
+// 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
 //       with the distribution.
@@ skipping 155 matching lines @@
 int FunctionLiteral::end_position() const {
   return scope()->end_position();
 }
 
 
 LanguageMode FunctionLiteral::language_mode() const {
   return scope()->language_mode();
 }
 
 
+bool FunctionLiteral::ShouldSelfOptimize() {
+  AstNodeType::Flag types = 0;
+  int node_count = 0;
+  CollectInfo(&types, &node_count);
+  return (types & (AstNodeType::kContainsBackEdgesMask |
+                   AstNodeType::kContainsCallsMask |
+                   AstNodeType::kPreventsOptimizationMask)) == 0;
+}
+
+
+int FunctionLiteral::AstNodeCount() {
+  AstNodeType::Flag types = 0;
+  int node_count = 0;
+  CollectInfo(&types, &node_count);
+  return node_count;
+}
+
+
 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;
   } else if (value_->AsLiteral() != NULL) {
@@ skipping 232 matching lines @@
 
 
 // ----------------------------------------------------------------------------
 // Inlining support
 
 bool Declaration::IsInlineable() const {
   return proxy()->var()->IsStackAllocated() && fun() == NULL;
 }
 
 
+void Declaration::CollectInfo(AstNodeType::Flag* flags,
+                              int* node_count) const {
+  proxy()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool TargetCollector::IsInlineable() const {
   UNREACHABLE();
   return false;
 }
 
 
 bool ForInStatement::IsInlineable() const {
   return false;
 }
 
 
+void ForInStatement::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  *flags |= AstNodeType::kForInStatementMask;
+  each()->CollectInfo(flags, node_count);
+  enumerable()->CollectInfo(flags, node_count);
+  body()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool WithStatement::IsInlineable() const {
   return false;
 }
 
 
+void WithStatement::CollectInfo(AstNodeType::Flag* flags,
+                                int* node_count) const {
+  *flags |= AstNodeType::kWithStatementMask;
+  expression()->CollectInfo(flags, node_count);
+  statement()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool SwitchStatement::IsInlineable() const {
   return false;
 }
 
 
+void SwitchStatement::CollectInfo(AstNodeType::Flag* flags,
+                                  int* node_count) const {
+  *flags |= AstNodeType::kSwitchStatementMask;
+  tag()->CollectInfo(flags, node_count);
+  for (int i = 0; i < cases()->length(); ++i) {
+    CaseClause* clause(cases()->at(i));
+    if (!clause->is_default()) {
+      clause->label()->CollectInfo(flags, node_count);
+    }
+    for (int j = 0; j < clause->statements()->length(); ++j) {
+      clause->statements()->at(j)->CollectInfo(flags, node_count);
+    }
+  }
+  *node_count += 1;
+}
+
+
 bool TryStatement::IsInlineable() const {
   return false;
 }
 
 
-bool TryCatchStatement::IsInlineable() const {
-  return false;
+void TryCatchStatement::CollectInfo(AstNodeType::Flag* flags,
+                                    int* node_count) const {
+  *flags |= AstNodeType::kTryCatchStatementMask;
+  try_block()->CollectInfo(flags, node_count);
+  catch_block()->CollectInfo(flags, node_count);
+  *node_count += 1;
 }
 
 
-bool TryFinallyStatement::IsInlineable() const {
-  return false;
+void TryFinallyStatement::CollectInfo(AstNodeType::Flag* flags,
+                                      int* node_count) const {
+  *flags |= AstNodeType::kTryFinallyStatementMask;
+  try_block()->CollectInfo(flags, node_count);
+  finally_block()->CollectInfo(flags, node_count);
+  *node_count += 1;
 }
 
 
 bool DebuggerStatement::IsInlineable() const {
   return false;
 }
 
 
+void DebuggerStatement::CollectInfo(AstNodeType::Flag* flags,
+                                    int* node_count) const {
+  *flags |= AstNodeType::kDebuggerStatementMask;
+  *node_count += 1;
+}
+
+
 bool Throw::IsInlineable() const {
   return exception()->IsInlineable();
 }
 
 
+void Throw::CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+  *flags |= AstNodeType::kThrowMask;
+  exception()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool MaterializedLiteral::IsInlineable() const {
   // TODO(1322): Allow materialized literals.
   return false;
 }
 
 
+void ObjectLiteral::CollectInfo(AstNodeType::Flag* flags,
+                                int* node_count) const {
+  *flags |= AstNodeType::kObjectLiteralMask;
+  for (int i = 0; i < properties()->length(); ++i) {
+    properties()->at(i)->key()->CollectInfo(flags, node_count);
+    properties()->at(i)->value()->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
+void RegExpLiteral::CollectInfo(AstNodeType::Flag* flags,
+                                int* node_count) const {
+  *flags |= AstNodeType::kRegExpLiteralMask;
+  *node_count += 1;
+}
+
+
+void ArrayLiteral::CollectInfo(AstNodeType::Flag* flags,
+                               int* node_count) const {
+  *flags |= AstNodeType::kArrayLiteralMask;
+  for (int i = 0; i < values()->length(); ++i) {
+    values()->at(i)->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
 bool FunctionLiteral::IsInlineable() const {
   // TODO(1322): Allow materialized literals.
   return false;
 }
 
 
+void FunctionLiteral::CollectInfo(AstNodeType::Flag* flags,
+                                  int* node_count) const {
+  *flags |= AstNodeType::kFunctionLiteralMask;
+  if (scope()->declarations() != NULL) {
+    for (int i = 0; i < scope()->declarations()->length(); ++i) {
+      scope()->declarations()->at(i)->CollectInfo(flags, node_count);
+    }
+  }
+  if (body() != NULL) {
+    for (int i = 0; i < body()->length(); ++i) {
+      body()->at(i)->CollectInfo(flags, node_count);
+    }
+  }
+  *node_count += 1;
+}
+
+
 bool ThisFunction::IsInlineable() const {
   return true;
 }
 
 
+void ThisFunction::CollectInfo(AstNodeType::Flag* flags,
+                               int* node_count) const {
+  *flags |= AstNodeType::kThisFunctionMask;
+  *node_count += 1;
+}
+
+
 bool SharedFunctionInfoLiteral::IsInlineable() const {
   return false;
 }
 
 
+void SharedFunctionInfoLiteral::CollectInfo(AstNodeType::Flag* flags,
+                                            int* node_count) const {
+  *flags |= AstNodeType::kSharedFunctionInfoLiteralMask;
+  *node_count += 1;
+}
+
+
 bool ForStatement::IsInlineable() const {
   return (init() == NULL || init()->IsInlineable())
       && (cond() == NULL || cond()->IsInlineable())
       && (next() == NULL || next()->IsInlineable())
       && body()->IsInlineable();
 }
 
 
+void ForStatement::CollectInfo(AstNodeType::Flag* flags,
+                               int* node_count) const {
+  *flags |= AstNodeType::kForStatementMask;
+  if (init() != NULL) init()->CollectInfo(flags, node_count);
+  if (cond() != NULL) cond()->CollectInfo(flags, node_count);
+  if (next() != NULL) next()->CollectInfo(flags, node_count);
+  body()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool WhileStatement::IsInlineable() const {
   return cond()->IsInlineable()
       && body()->IsInlineable();
 }
 
 
+void WhileStatement::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  *flags |= AstNodeType::kWhileStatementMask;
+  cond()->CollectInfo(flags, node_count);
+  body()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool DoWhileStatement::IsInlineable() const {
   return cond()->IsInlineable()
       && body()->IsInlineable();
 }
 
 
+void DoWhileStatement::CollectInfo(AstNodeType::Flag* flags,
+                                   int* node_count) const {
+  *flags |= AstNodeType::kDoWhileStatementMask;
+  cond()->CollectInfo(flags, node_count);
+  body()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool ContinueStatement::IsInlineable() const {
   return true;
 }
 
 
+void ContinueStatement::CollectInfo(AstNodeType::Flag* flags,
+                                    int* node_count) const {
+  *flags |= AstNodeType::kContinueStatementMask;
+  *node_count += 1;
+}
+
+
 bool BreakStatement::IsInlineable() const {
   return true;
 }
 
 
+void BreakStatement::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  *flags |= AstNodeType::kBreakStatementMask;
+  *node_count += 1;
+}
+
+
 bool EmptyStatement::IsInlineable() const {
   return true;
 }
 
 
+void EmptyStatement::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  // Nothing to see here, move on.
+}
+
+
 bool Literal::IsInlineable() const {
   return true;
 }
 
 
 bool Block::IsInlineable() const {
   const int count = statements_.length();
   for (int i = 0; i < count; ++i) {
     if (!statements_[i]->IsInlineable()) return false;
   }
   return true;
 }
 
 
+void Block::CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+  for (int i = 0; i < statements_.length(); ++i) {
+    statements_[i]->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
 bool ExpressionStatement::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+void ExpressionStatement::CollectInfo(AstNodeType::Flag* flags,
+                                      int* node_count) const {
+  expression()->CollectInfo(flags, node_count);
+}
+
+
 bool IfStatement::IsInlineable() const {
   return condition()->IsInlineable()
       && then_statement()->IsInlineable()
       && else_statement()->IsInlineable();
 }
 
 
+void IfStatement::CollectInfo(AstNodeType::Flag* flags,
+                              int* node_count) const {
+  *flags |= AstNodeType::kIfStatementMask;
+  condition()->CollectInfo(flags, node_count);
+  then_statement()->CollectInfo(flags, node_count);
+  else_statement()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
+
 bool ReturnStatement::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+void ReturnStatement::CollectInfo(AstNodeType::Flag* flags,
+                                  int* node_count) const {
+  *flags |= AstNodeType::kReturnStatementMask;
+  expression()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool Conditional::IsInlineable() const {
   return condition()->IsInlineable() && then_expression()->IsInlineable() &&
       else_expression()->IsInlineable();
 }
 
 
+void Conditional::CollectInfo(AstNodeType::Flag* flags,
+                              int* node_count) const {
+  *flags |= AstNodeType::kConditionalMask;
+  condition()->CollectInfo(flags, node_count);
+  then_expression()->CollectInfo(flags, node_count);
+  else_expression()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool VariableProxy::IsInlineable() const {
   return var()->IsUnallocated()
       || var()->IsStackAllocated()
       || var()->IsContextSlot();
 }
 
 
 bool Assignment::IsInlineable() const {
   return target()->IsInlineable() && value()->IsInlineable();
 }
 
 
+void Assignment::CollectInfo(AstNodeType::Flag* flags,
+                             int* node_count) const {
+  target()->CollectInfo(flags, node_count);
+  value()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool Property::IsInlineable() const {
   return obj()->IsInlineable() && key()->IsInlineable();
 }
 
 
+void Property::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  *flags |= AstNodeType::kPropertyMask;
+  obj()->CollectInfo(flags, node_count);
+  key()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool Call::IsInlineable() const {
   if (!expression()->IsInlineable()) return false;
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
     if (!arguments()->at(i)->IsInlineable()) return false;
   }
   return true;
 }
 
 
+void Call::CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+  *flags |= AstNodeType::kCallMask;
+  expression()->CollectInfo(flags, node_count);
+  for (int i = 0; i < arguments()->length(); ++i) {
+    arguments()->at(i)->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
 bool CallNew::IsInlineable() const {
   if (!expression()->IsInlineable()) return false;
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
     if (!arguments()->at(i)->IsInlineable()) return false;
   }
   return true;
 }
 
 
+void CallNew::CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+  *flags |= AstNodeType::kCallNewMask;
+  expression()->CollectInfo(flags, node_count);
+  for (int i = 0; i < arguments()->length(); ++i) {
+    arguments()->at(i)->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
 bool CallRuntime::IsInlineable() 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;
   }
   const int count = arguments()->length();
   for (int i = 0; i < count; ++i) {
     if (!arguments()->at(i)->IsInlineable()) return false;
   }
   return true;
 }
 
 
+void CallRuntime::CollectInfo(AstNodeType::Flag* flags, int* node_count) const {
+  *flags |= AstNodeType::kCallRuntimeMask;
+  for (int i = 0; i < arguments()->length(); ++i) {
+    arguments()->at(i)->CollectInfo(flags, node_count);
+  }
+  *node_count += 1;
+}
+
+
 bool UnaryOperation::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+void UnaryOperation::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  expression()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool BinaryOperation::IsInlineable() const {
   return left()->IsInlineable() && right()->IsInlineable();
 }
 
 
+void BinaryOperation::CollectInfo(AstNodeType::Flag* flags,
+                                  int* node_count) const {
+  left()->CollectInfo(flags, node_count);
+  right()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool CompareOperation::IsInlineable() const {
   return left()->IsInlineable() && right()->IsInlineable();
 }
 
 
+void CompareOperation::CollectInfo(AstNodeType::Flag* flags,
+                                   int* node_count) const {
+  left()->CollectInfo(flags, node_count);
+  right()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 bool CountOperation::IsInlineable() const {
   return expression()->IsInlineable();
 }
 
 
+void CountOperation::CollectInfo(AstNodeType::Flag* flags,
+                                 int* node_count) const {
+  expression()->CollectInfo(flags, node_count);
+  *node_count += 1;
+}
+
+
 // ----------------------------------------------------------------------------
 // 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();
   if (key()->IsPropertyName()) {
     if (oracle->LoadIsBuiltin(this, Builtins::kLoadIC_ArrayLength)) {
       is_array_length_ = true;
@@ skipping 555 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