Add name inference for anonymous functions to facilitate debugging and profiling of JS code.

src/rewriter.cc

 // Copyright 2006-2008 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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "ast.h"
+#include "func-name-inferrer.h"
 #include "scopes.h"
 #include "rewriter.h"
 
 namespace v8 { namespace internal {
 
 
 class AstOptimizer: public AstVisitor {
  public:
-  explicit AstOptimizer() {
+  explicit AstOptimizer() {}
+  explicit AstOptimizer(Handle<String> enclosing_name) {
+    func_name_inferrer_.PushEnclosingName(enclosing_name);
   }
 
   void Optimize(ZoneList<Statement*>* statements);
 
  private:
   // Used for loop condition analysis.  Cleared before visiting a loop
   // condition, set when a function literal is visited.
   bool has_function_literal_;
+  // Helper object for function name inferring.
+  FuncNameInferrer func_name_inferrer_;
 
   // Helpers
   void OptimizeArguments(ZoneList<Expression*>* arguments);
 
   // Node visitors.
 #define DEF_VISIT(type) \
   virtual void Visit##type(type* node);
   NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
@@ skipping 120 matching lines @@
   USE(node);
 }
 
 
 void AstOptimizer::VisitDebuggerStatement(DebuggerStatement* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitFunctionLiteral(FunctionLiteral* node) {
-  USE(node);
   has_function_literal_ = true;
+
+  if (node->name()->length() == 0) {
+    // Anonymous function.
+    func_name_inferrer_.SetFuncToInfer(node);
+  }
 }
 
 
 void AstOptimizer::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitConditional(Conditional* node) {
   Visit(node->condition());
   Visit(node->then_expression());
   Visit(node->else_expression());
 }
 
 
 void AstOptimizer::VisitSlot(Slot* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitVariableProxy(VariableProxy* node) {
   Variable* var = node->AsVariable();
   if (var != NULL) {
     if (var->type()->IsKnown()) {
       node->type()->CopyFrom(var->type());
     } else if (node->type()->IsLikelySmi()) {
       var->type()->SetAsLikelySmi();
     }
+
+    if (!var->is_this() &&
+        !Heap::result_symbol()->Equals(*var->name())) {
+      func_name_inferrer_.PushName(var->name());
+    }
   }
 }
 
 
 void AstOptimizer::VisitLiteral(Literal* node) {
   Handle<Object> literal = node->handle();
   if (literal->IsSmi()) {
     node->type()->SetAsLikelySmi();
+  } else if (literal->IsString()) {
+    Handle<String> lit_str(Handle<String>::cast(literal));
+    if (!Heap::prototype_symbol()->Equals(*lit_str)) {
+      func_name_inferrer_.PushName(lit_str);
+    }
   }
 }
 
 
 void AstOptimizer::VisitRegExpLiteral(RegExpLiteral* node) {
   USE(node);
 }
 
 
 void AstOptimizer::VisitArrayLiteral(ArrayLiteral* node) {
   for (int i = 0; i < node->values()->length(); i++) {
     Visit(node->values()->at(i));
   }
 }
 
-
 void AstOptimizer::VisitObjectLiteral(ObjectLiteral* node) {
   for (int i = 0; i < node->properties()->length(); i++) {
+    ScopedFuncNameInferrer scoped_fni(&func_name_inferrer_);
+    scoped_fni.Enter();
     Visit(node->properties()->at(i)->key());
     Visit(node->properties()->at(i)->value());
   }
 }
 
 
 void AstOptimizer::VisitCatchExtensionObject(CatchExtensionObject* node) {
   Visit(node->key());
   Visit(node->value());
 }
 
 
 void AstOptimizer::VisitAssignment(Assignment* node) {
+  ScopedFuncNameInferrer scoped_fni(&func_name_inferrer_);
   switch (node->op()) {
     case Token::INIT_VAR:
     case Token::INIT_CONST:
     case Token::ASSIGN:
       // No type can be infered from the general assignment.
+
+      if (node->value()->AsFunctionLiteral() != NULL ||
+          node->value()->AsObjectLiteral() != NULL) {
+        scoped_fni.Enter();
+      }
       break;
     case Token::ASSIGN_BIT_OR:
     case Token::ASSIGN_BIT_XOR:
     case Token::ASSIGN_BIT_AND:
     case Token::ASSIGN_SHL:
     case Token::ASSIGN_SAR:
     case Token::ASSIGN_SHR:
       node->type()->SetAsLikelySmiIfUnknown();
       node->target()->type()->SetAsLikelySmiIfUnknown();
       node->value()->type()->SetAsLikelySmiIfUnknown();
@@ skipping 88 matching lines @@
 }
 
 
 void AstOptimizer::VisitCallNew(CallNew* node) {
   Visit(node->expression());
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitCallRuntime(CallRuntime* node) {
+  ScopedFuncNameInferrer scoped_fni(&func_name_inferrer_);
+  if (Factory::InitializeVarGlobal_symbol()->Equals(*node->name()) &&
+      node->arguments()->length() >= 2 &&
+      node->arguments()->at(1)->AsFunctionLiteral() != NULL) {
+      scoped_fni.Enter();
+  }
   OptimizeArguments(node->arguments());
 }
 
 
 void AstOptimizer::VisitUnaryOperation(UnaryOperation* node) {
   Visit(node->expression());
 }
 
 
 void AstOptimizer::VisitCountOperation(CountOperation* node) {
@@ skipping 406 matching lines @@
 
   if (processor.result_assigned()) body->Add(new ReturnStatement(result));
   return true;
 }
 
 
 bool Rewriter::Optimize(FunctionLiteral* function) {
   ZoneList<Statement*>* body = function->body();
 
   if (FLAG_optimize_ast && !body->is_empty()) {
-    Scope* scope = function->scope();
-    if (!scope->is_global_scope()) {
-      AstOptimizer optimizer;
-      optimizer.Optimize(body);
-      if (optimizer.HasStackOverflow()) {
-        return false;
-      }
+    AstOptimizer optimizer(function->name());
+    optimizer.Optimize(body);
+    if (optimizer.HasStackOverflow()) {
+      return false;
     }
   }
   return true;
 }
 
 
 } }  // namespace v8::internal