In the IA32 code genrator, handle call ICs and constructor calls the...

src/codegen-ia32.cc

 // Copyright 2006-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 3859 matching lines @@
     // patch the stack to use the global proxy as 'this' in the
     // invoked function.
     LoadGlobal();
 
     // Load the arguments.
     int arg_count = args->length();
     for (int i = 0; i < arg_count; i++) {
       Load(args->at(i));
     }
 
-    // Setup the receiver register and call the IC initialization code.
-    Handle<Code> stub = (loop_nesting() > 0)
-        ? ComputeCallInitializeInLoop(arg_count)
-        : ComputeCallInitialize(arg_count);
+    // Call the IC initialization code.
     CodeForSourcePosition(node->position());
-    Result result = frame_->CallCodeObject(stub,
-                                           RelocInfo::CODE_TARGET_CONTEXT,
-                                           arg_count + 1);
+    Result result = frame_->CallCallIC(RelocInfo::CODE_TARGET_CONTEXT,
+                                       arg_count,
+                                       loop_nesting());
     frame_->RestoreContextRegister();
-
     // Replace the function on the stack with the result.
     frame_->SetElementAt(0, &result);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript example: 'with (obj) foo(1, 2, 3)'  // foo is in obj
     // ----------------------------------
 
     // Load the function
@@ skipping 22 matching lines @@
       frame_->Push(literal->handle());
       Load(property->obj());
 
       // Load the arguments.
       int arg_count = args->length();
       for (int i = 0; i < arg_count; i++) {
         Load(args->at(i));
       }
 
       // Call the IC initialization code.
-      Handle<Code> stub = (loop_nesting() > 0)
-        ? ComputeCallInitializeInLoop(arg_count)
-        : ComputeCallInitialize(arg_count);
       CodeForSourcePosition(node->position());
-      Result result = frame_->CallCodeObject(stub,
-                                             RelocInfo::CODE_TARGET,
-                                             arg_count + 1);
+      Result result =
+          frame_->CallCallIC(RelocInfo::CODE_TARGET, arg_count, loop_nesting());
       frame_->RestoreContextRegister();
-
       // Replace the function on the stack with the result.
       frame_->SetElementAt(0, &result);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
       // Load the function to call from the property through a reference.
       Reference ref(this, property);
@@ skipping 45 matching lines @@
   Load(node->expression());
   LoadGlobal();
 
   // Push the arguments ("left-to-right") on the stack.
   ZoneList<Expression*>* args = node->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
-  // Constructors are called with the number of arguments in register
-  // eax for now. Another option would be to have separate construct
-  // call trampolines per different arguments counts encountered.
-  Result num_args = allocator()->Allocate(eax);
-  ASSERT(num_args.is_valid());
-  __ Set(num_args.reg(), Immediate(arg_count));
-
-  // Load the function into temporary function slot as per calling
-  // convention.
-  frame_->PushElementAt(arg_count + 1);
-  Result function = frame_->Pop();
-  function.ToRegister(edi);
-  ASSERT(function.is_valid());
-
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
   CodeForSourcePosition(node->position());
-  Handle<Code> ic(Builtins::builtin(Builtins::JSConstructCall));
-  Result result = frame_->CallCodeObject(ic,
-                                         RelocInfo::CONSTRUCT_CALL,
-                                         &num_args,
-                                         &function,
-                                         arg_count + 1);
-
+  Result result = frame_->CallConstructor(arg_count);
   // Replace the function on the stack with the result.
   frame_->SetElementAt(0, &result);
 }
 
 
 void CodeGenerator::VisitCallEval(CallEval* node) {
   Comment cmnt(masm_, "[ CallEval");
 
   // In a call to eval, we first call %ResolvePossiblyDirectEval to resolve
   // the function we need to call and the receiver of the call.
@@ skipping 392 matching lines @@
     frame_->Push(&temp);
   }
 
   // Push the arguments ("left-to-right").
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
   if (function == NULL) {
-    // Call the JS runtime function.
-    Handle<Code> stub = ComputeCallInitialize(arg_count);
-    Result answer =
-        frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
+    // Call the JS runtime function.  Pass 0 as the loop nesting depth
+    // because we do not handle runtime calls specially in loops.
+    Result answer = frame_->CallCallIC(RelocInfo::CODE_TARGET, arg_count, 0);
     frame_->RestoreContextRegister();
     frame_->SetElementAt(0, &answer);
   } else {
     // Call the C runtime function.
     Result answer = frame_->CallRuntime(function, arg_count);
     frame_->Push(&answer);
   }
 }
 
 
@@ skipping 2487 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal