Implement %_CallFunction in hydrogen.

src/hydrogen.cc

 // Copyright 2010 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 4266 matching lines @@
       return;
 
     } else {
       call = new HCallNamed(name, argument_count);
     }
 
   } else {
     Variable* var = expr->expression()->AsVariableProxy()->AsVariable();
     bool global_call = (var != NULL) && var->is_global() && !var->is_this();
 
-    if (!global_call) {
-      ++argument_count;

[Kevin Millikin (Chromium), 2010/12/21 10:38:50]

Please don't make this change.

I'm currently refactoring the HGraphBuilder (per my status reports on v8-dev). 
This will introduce conflicts :)

-      VisitArgument(expr->expression());
-      CHECK_BAILOUT;
-    }
-
     if (global_call) {
       // If there is a global property cell for the name at compile time and
       // access check is not enabled we assume that the function will not change
       // and generate optimized code for calling the function.
       CompilationInfo* info = graph()->info();
       bool known_global_function = info->has_global_object() &&
           !info->global_object()->IsAccessCheckNeeded() &&
           expr->ComputeGlobalTarget(Handle<GlobalObject>(info->global_object()),
                                     var->name());
       if (known_global_function) {
@@ skipping 34 matching lines @@
         CHECK_BAILOUT;
 
         call = new HCallKnownGlobal(expr->target(), argument_count);
       } else {
         PushAndAdd(new HGlobalObject);
         VisitArgumentList(expr->arguments());
         CHECK_BAILOUT;
 
         call = new HCallGlobal(var->name(), argument_count);
       }
+    } else {
+      // Non-global call.
+      ++argument_count;
+      VisitArgument(expr->expression());
+      CHECK_BAILOUT;
 
-    } else {
       PushAndAdd(new HGlobalReceiver);
       VisitArgumentList(expr->arguments());
       CHECK_BAILOUT;
 
       call = new HCallFunction(argument_count);
     }
   }
 
   call->set_position(expr->position());
   ProcessCall(call);
@@ skipping 779 matching lines @@
 // Fast swapping of elements. Takes three expressions, the object and two
 // indices. This should only be used if the indices are known to be
 // non-negative and within bounds of the elements array at the call site.
 void HGraphBuilder::GenerateSwapElements(int argument_count, int ast_id) {
   BAILOUT("inlined runtime function: SwapElements");
 }
 
 
 // Fast call for custom callbacks.
 void HGraphBuilder::GenerateCallFunction(int argument_count, int ast_id) {
-  BAILOUT("inlined runtime function: CallFunction");
+  // BAILOUT("boo");

[Lasse Reichstein, 2010/12/21 10:19:21]

I'll remove this :)

[Søren Thygesen Gjesse, 2010/12/21 10:25:03]

Strange comment.

+  ASSERT(argument_count >= 2);
+  // Move function from top of stack to below arguments.
+  HValue* function = Pop();
+  int argc = argument_count - 1;  // Don't count the function itself.
+  SmartPointer<HValue*> arguments(NewArray<HValue*>(argc));
+  for (int i = 0; i < argc; i++) { arguments[i] = Pop(); }

[Søren Thygesen Gjesse, 2010/12/21 10:25:03]

We normally split for statements across three lines.

+  Push(function);
+  for (int i = argc - 1; i >= 0; i--) { Push(arguments[i]); }

[Søren Thygesen Gjesse, 2010/12/21 10:25:03]

Ditto.

+  HCallFunction* result = new HCallFunction(argument_count);
+  ProcessCall(result);
+  ast_context()->ReturnInstruction(result, ast_id);
 }
 
 
 // Fast call to math functions.
 void HGraphBuilder::GenerateMathPow(int argument_count, int ast_id) {
   ASSERT_EQ(2, argument_count);
   HValue* right = Pop();
   HValue* left = Pop();
   HPower* result = new HPower(left, right);
   ast_context()->ReturnInstruction(result, ast_id);
@@ skipping 518 matching lines @@
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (chunk_ != NULL) chunk_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal