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

src/arm/fast-codegen-arm.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 74 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);

[fschneider, 2009/11/03 14:10:13]

Why this duplicate ASSERT? (also on ia32, x64)

[Kevin Millikin (Chromium), 2009/11/03 14:16:09]

We should not be in a loop before we compile the body, and we should not be in a
loop afterward either.

   }
 
   { Comment cmnt(masm_, "[ return <undefined>;");
     // Emit a 'return undefined' in case control fell off the end of the
     // body.
     __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
   }
   { Comment cmnt(masm_, "Return sequence");
     if (return_label_.is_bound()) {
       __ b(&return_label_);
@@ skipping 210 matching lines @@
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     DropAndMove(expr->context(), r0);
   } 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:
   // r4 = JS function, literals array
   // r3 = literal index
   // r2 = RegExp pattern
   // r1 = RegExp flags
   // r0 = temp + return value (RegExp literal)
   __ ldr(r0, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
   __ ldr(r4,  FieldMemOperand(r0, JSFunction::kLiteralsOffset));
   int literal_offset =
@@ skipping 474 matching lines @@
         __ ldr(r1, CodeGenerator::GlobalObject());
       } else {
         __ ldr(r1, MemOperand(sp, kPointerSize));
       }
       // Overwrite (object, key) with (function, receiver).
       __ str(r0, MemOperand(sp, kPointerSize));
       __ str(r1, MemOperand(sp));
       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();

[Søren Thygesen Gjesse, 2009/11/03 13:57:47]

As this logic is duplicated in all three code generators how about moving it to
the FunctionLiteral passing the current loop_depth (or the
FastCodeGenerator/CodeGenerator object)?

[Kevin Millikin (Chromium), 2009/11/03 14:16:09]

That's a good idea.  For now the check is pretty simple, so I'll leave it out of
the AST.

+    }
+    Visit(fun);
     // Load global receiver object.
     __ ldr(r1, CodeGenerator::GlobalObject());
     __ ldr(r1, FieldMemOperand(r1, GlobalObject::kGlobalReceiverOffset));
     __ push(r1);
     // Emit function call.
     EmitCallWithStub(expr);
   }
 }
 
 
@@ skipping 50 matching lines @@
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
 
   __ CallRuntime(function, arg_count);
   Move(expr->context(), r0);
 }
 
 
 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 77 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_JS);
 
   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(r0);
       break;
     case Expression::kEffect:
       // Do not save result.
       break;
   }
   // Call runtime for +1/-1.
   __ push(r0);
   __ mov(ip, Operand(Smi::FromInt(1)));
   __ push(ip);
   if (expr->op() == Token::INC) {
     __ CallRuntime(Runtime::kNumberAdd, 2);
   } else {
     __ CallRuntime(Runtime::kNumberSub, 2);
   }
   // Call Store IC.
-  __ mov(r2, Operand(v->AsVariable()->name()));
+  __ mov(r2, Operand(proxy->AsVariable()->name()));
   __ ldr(ip, CodeGenerator::GlobalObject());
   __ push(ip);
   Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
   __ Call(ic, RelocInfo::CODE_TARGET);
   // Restore up stack after store IC.
   __ add(sp, sp, Operand(kPointerSize));
 
   switch (expr->context()) {
     case Expression::kUninitialized:
       UNREACHABLE();
@@ skipping 22 matching lines @@
       __ bind(&discard);
       __ add(sp, sp, Operand(kPointerSize));
       __ b(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 25 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 145 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal