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

src/x64/fast-codegen-x64.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 66 matching lines @@
 
   { Comment cmnt(masm_, "[ Declarations");
     VisitDeclarations(fun->scope()->declarations());
   }
 
   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.
     __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
   }
   { Comment cmnt(masm_, "Return sequence");
     SetReturnPosition(fun);
 
@@ skipping 255 matching lines @@
     // is no test rax instruction here.
     DropAndMove(expr->context(), rax);
   } 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:
   // rdi = JS function.
   // rbx = literals array.
   // rax = regexp literal.
   __ movq(rdi, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
   __ movq(rbx, FieldOperand(rdi, JSFunction::kLiteralsOffset));
   int literal_offset =
     FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ movq(rax, FieldOperand(rbx, literal_offset));
@@ skipping 474 matching lines @@
       __ push(rax);
       // Push receiver object on stack.
       if (prop->is_synthetic()) {
         __ push(CodeGenerator::GlobalObject());
       } else {
         __ push(rbx);
       }
       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.
     __ movq(rbx, CodeGenerator::GlobalObject());
     __ push(FieldOperand(rbx, GlobalObject::kGlobalReceiverOffset));
     // Emit function call.
     EmitCallWithStub(expr);
   }
 }
 
 
 void FastCodeGenerator::VisitCallNew(CallNew* expr) {
@@ skipping 48 matching lines @@
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
 
   __ CallRuntime(function, arg_count);
   Move(expr->context(), rax);
 }
 
 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(rax);
       break;
     case Expression::kEffect:
       // Do not save result.
       break;
   }
   // Call runtime for +1/-1.
   __ push(rax);
   __ Push(Smi::FromInt(1));
   if (expr->op() == Token::INC) {
     __ CallRuntime(Runtime::kNumberAdd, 2);
   } else {
     __ CallRuntime(Runtime::kNumberSub, 2);
   }
   // Call Store IC.
-  __ Move(rcx, v->AsVariable()->name());
+  __ Move(rcx, 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
   __ addq(rsp, Immediate(kPointerSize));
 
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:  // Fall through
@@ skipping 22 matching lines @@
       __ addq(rsp, Immediate(kPointerSize));
       __ jmp(true_label_);
       break;
     }
   }
 }
 
 
 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::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 138 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal