Begin using the top-level code generator for code that is inside...

src/ia32/fast-codegen-ia32.cc

 // Copyright 2009 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 67 matching lines @@
     StackCheckStub stub;
     __ CallStub(&stub);
     __ bind(&ok);
   }
 
   if (FLAG_trace) {
     __ CallRuntime(Runtime::kTraceEnter, 0);
   }
 
   { Comment cmnt(masm_, "[ Body");
+    ASSERT(loop_depth() == 0);
     VisitStatements(fun->body());
+    ASSERT(loop_depth() == 0);
   }
 
   { Comment cmnt(masm_, "[ return <undefined>;");
     // Emit a 'return undefined' in case control fell off the end of the
     // body.
     __ mov(eax, Factory::undefined_value());
   }
   { Comment cmnt(masm_, "[ Return sequence");
     SetReturnPosition(fun);
 
@@ skipping 236 matching lines @@
 
     DropAndMove(expr->context(), eax);
   } else {
     Comment cmnt(masm_, "Stack slot");
     Move(expr->context(), rewrite->AsSlot());
   }
 }
 
 
 void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
-  Comment cmnt(masm_, "[ RegExp Literal");
+  Comment cmnt(masm_, "[ RegExpLiteral");
   Label done;
   // Registers will be used as follows:
   // edi = JS function.
   // ebx = literals array.
   // eax = regexp literal.
   __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
   __ mov(ebx, FieldOperand(edi, JSFunction::kLiteralsOffset));
   int literal_offset =
     FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ mov(eax, FieldOperand(ebx, literal_offset));
@@ skipping 477 matching lines @@
       __ push(eax);
       // Push receiver object on stack.
       if (prop->is_synthetic()) {
         __ push(CodeGenerator::GlobalObject());
       } else {
         __ push(ebx);
       }
       EmitCallWithStub(expr);
     }
   } else {
-    // Call to some other function expression.
-    Visit(expr->expression());
+    // Call to some other expression.  If the expression is an anonymous
+    // function literal not called in a loop, mark it as one that should
+    // also use the fast code generator.
+    FunctionLiteral* lit = fun->AsFunctionLiteral();
+    if (lit != NULL &&
+        lit->name()->Equals(Heap::empty_string()) &&
+        loop_depth() == 0) {
+      lit->mark_as_fast();
+    }
+    Visit(fun);
     // Load global receiver object.
     __ mov(ebx, CodeGenerator::GlobalObject());
     __ push(FieldOperand(ebx, GlobalObject::kGlobalReceiverOffset));
     // Emit function call.
     EmitCallWithStub(expr);
   }
 }
 
+
 void FastCodeGenerator::VisitCallNew(CallNew* expr) {
   Comment cmnt(masm_, "[ CallNew");
   // According to ECMA-262, section 11.2.2, page 44, the function
   // expression in new calls must be evaluated before the
   // arguments.
   // Push function on the stack.
   Visit(expr->expression());
   ASSERT_EQ(Expression::kValue, expr->expression()->context());
 
   // Push global object (receiver).
@@ skipping 40 matching lines @@
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
 
   __ CallRuntime(function, arg_count);
   Move(expr->context(), eax);
 }
 
 
 void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   Comment cmnt(masm_, "[ UnaryOperation");
-
   switch (expr->op()) {
     case Token::VOID:
       Visit(expr->expression());
       ASSERT_EQ(Expression::kEffect, expr->expression()->context());
       switch (expr->context()) {
         case Expression::kUninitialized:
           UNREACHABLE();
           break;
         case Expression::kEffect:
           break;
@@ skipping 72 matching lines @@
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCountOperation(CountOperation* expr) {
-  VariableProxy* v = expr->expression()->AsVariableProxy();
-  ASSERT(v->AsVariable() != NULL);
-  ASSERT(v->AsVariable()->is_global());
+  Comment cmnt(masm_, "[ CountOperation");
+  VariableProxy* proxy = expr->expression()->AsVariableProxy();
+  ASSERT(proxy->AsVariable() != NULL);
+  ASSERT(proxy->AsVariable()->is_global());
 
-  Visit(v);
-
+  Visit(proxy);
   __ InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION);
 
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kValue:  // Fall through
     case Expression::kTest:  // Fall through
     case Expression::kTestValue:  // Fall through
     case Expression::kValueTest:
       // Duplicate the result on the stack.
       __ push(eax);
       break;
     case Expression::kEffect:
       // Do not save result.
       break;
   }
   // Call runtime for +1/-1.
   __ push(eax);
   __ push(Immediate(Smi::FromInt(1)));
   if (expr->op() == Token::INC) {
     __ CallRuntime(Runtime::kNumberAdd, 2);
   } else {
     __ CallRuntime(Runtime::kNumberSub, 2);
   }
   // Call Store IC.
-  __ mov(ecx, v->AsVariable()->name());
+  __ mov(ecx, proxy->AsVariable()->name());
   __ push(CodeGenerator::GlobalObject());
   Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
   // Restore up stack after store IC.
   __ add(Operand(esp), Immediate(kPointerSize));
 
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:  // Fall through
@@ skipping 21 matching lines @@
       __ bind(&discard);
       __ add(Operand(esp), Immediate(kPointerSize));
       __ jmp(true_label_);
       break;
     }
   }
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
+  Comment cmnt(masm_, "[ BinaryOperation");
   switch (expr->op()) {
     case Token::COMMA:
       ASSERT_EQ(Expression::kEffect, expr->left()->context());
       ASSERT_EQ(expr->context(), expr->right()->context());
       Visit(expr->left());
       Visit(expr->right());
       break;
 
     case Token::OR:
     case Token::AND:
@@ skipping 24 matching lines @@
 
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCompareOperation(CompareOperation* expr) {
+  Comment cmnt(masm_, "[ CompareOperation");
   ASSERT_EQ(Expression::kValue, expr->left()->context());
   ASSERT_EQ(Expression::kValue, expr->right()->context());
   Visit(expr->left());
   Visit(expr->right());
 
   // Convert current context to test context: Pre-test code.
   Label push_true;
   Label push_false;
   Label done;
   Label* saved_true = true_label_;
@@ skipping 141 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal