Support for calls on named and keyed properties of the form:...

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 47 matching lines @@
   __ push(esi);  // Callee's context.
   __ push(edi);  // Callee's JS Function.
 
   { Comment cmnt(masm_, "[ Allocate locals");
     int locals_count = fun->scope()->num_stack_slots();
     for (int i = 0; i < locals_count; i++) {
       __ push(Immediate(Factory::undefined_value()));
     }
   }
 
+  { Comment cmnt(masm_, "[ Declarations");
+    VisitDeclarations(fun->scope()->declarations());
+  }
+
   { Comment cmnt(masm_, "[ Stack check");
     Label ok;
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     __ j(above_equal, &ok, taken);
     StackCheckStub stub;
     __ CallStub(&stub);
     __ bind(&ok);
   }
 
-  { Comment cmnt(masm_, "[ Declarations");
-    VisitDeclarations(fun->scope()->declarations());
-  }
-
   if (FLAG_trace) {
     __ CallRuntime(Runtime::kTraceEnter, 0);
   }
 
   { Comment cmnt(masm_, "[ Body");
     VisitStatements(fun->body());
   }
 
   { 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);
 
-    if (FLAG_trace) {
-      __ push(eax);
-      __ CallRuntime(Runtime::kTraceExit, 1);
+    if (return_label_.is_bound()) {
+      __ jmp(&return_label_);
+    } else {
+      // Common return label
+      __ bind(&return_label_);
+
+      if (FLAG_trace) {
+        __ push(eax);
+        __ CallRuntime(Runtime::kTraceExit, 1);
+      }
+      __ RecordJSReturn();
+      // Do not use the leave instruction here because it is too short to
+      // patch with the code required by the debugger.
+      __ mov(esp, ebp);
+      __ pop(ebp);
+      __ ret((fun->scope()->num_parameters() + 1) * kPointerSize);
     }
-    __ RecordJSReturn();
-    // Do not use the leave instruction here because it is too short to
-    // patch with the code required by the debugger.
-    __ mov(esp, ebp);
-    __ pop(ebp);
-    __ ret((fun->scope()->num_parameters() + 1) * kPointerSize);
   }
 }
 
 
 void FastCodeGenerator::Move(Expression::Context context, Slot* source) {
   switch (context) {
     case Expression::kUninitialized:
       UNREACHABLE();
     case Expression::kEffect:
       break;
@@ skipping 47 matching lines @@
   SetStatementPosition(stmt);
   Expression* expr = stmt->expression();
   if (expr->AsLiteral() != NULL) {
     __ mov(eax, expr->AsLiteral()->handle());
   } else {
     ASSERT_EQ(Expression::kValue, expr->context());
     Visit(expr);
     __ pop(eax);
   }
 
-  if (FLAG_trace) {
-    __ push(eax);
-    __ CallRuntime(Runtime::kTraceExit, 1);
+  if (return_label_.is_bound()) {
+    __ jmp(&return_label_);
+  } else {
+    __ bind(&return_label_);
+
+      if (FLAG_trace) {
+        __ push(eax);
+        __ CallRuntime(Runtime::kTraceExit, 1);
+      }
+
+    __ RecordJSReturn();
+
+    // Do not use the leave instruction here because it is too short to
+    // patch with the code required by the debugger.
+    __ mov(esp, ebp);
+    __ pop(ebp);
+    __ ret((function_->scope()->num_parameters() + 1) * kPointerSize);
   }
-  __ RecordJSReturn();
-
-  // Do not use the leave instruction here because it is too short to
-  // patch with the code required by the debugger.
-  __ mov(esp, ebp);
-  __ pop(ebp);
-  __ ret((function_->scope()->num_parameters() + 1) * kPointerSize);
 }
 
 
 void FastCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
   // Build the function boilerplate and instantiate it.
   Handle<JSFunction> boilerplate = BuildBoilerplate(expr);
   if (HasStackOverflow()) return;
 
@@ skipping 282 matching lines @@
     // on the stack.
 
     // Code for the right-hand-side expression depends on its type.
     if (rhs->AsLiteral() != NULL) {
       __ mov(eax, rhs->AsLiteral()->handle());
     } else {
       ASSERT_EQ(Expression::kValue, rhs->context());
       Visit(rhs);
       __ pop(eax);
     }
+    // Record position for debugger.
+    SetSourcePosition(expr->position());
     __ mov(ecx, var->name());
     __ push(CodeGenerator::GlobalObject());
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
     // Overwrite the global object on the stack with the result if needed.
     DropAndMove(expr->context(), eax);
   } else {
     // Local or parameter assignment.
     ASSERT(var->slot() != NULL);
 
@@ skipping 29 matching lines @@
 void FastCodeGenerator::VisitProperty(Property* expr) {
   Comment cmnt(masm_, "[ Property");
   Expression* key = expr->key();
   uint32_t dummy;
 
   // Record the source position for the property load.
   SetSourcePosition(expr->position());
 
   // Evaluate receiver.
   Visit(expr->obj());
+
   if (key->AsLiteral() != NULL && key->AsLiteral()->handle()->IsSymbol() &&
       !String::cast(*(key->AsLiteral()->handle()))->AsArrayIndex(&dummy)) {
     // Do a NAMED property load.
     // The IC expects the property name in ecx and the receiver on the stack.
     __ mov(ecx, Immediate(key->AsLiteral()->handle()));
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
     // By emitting a nop we make sure that we do not have a test eax
     // instruction after the call it is treated specially by the LoadIC code.
     __ nop();
   } else {
     // Do a KEYED property load.
     Visit(expr->key());
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
     __ call(ic, RelocInfo::CODE_TARGET);
     // By emitting a nop we make sure that we do not have a "test eax,..."
     // instruction after the call it is treated specially by the LoadIC code.
     __ nop();
     // Drop key left on the stack by IC.
     __ add(Operand(esp), Immediate(kPointerSize));
   }
   DropAndMove(expr->context(), eax);
 }
 
 
-void FastCodeGenerator::VisitCall(Call* expr) {
-  Expression* fun = expr->expression();
+void FastCodeGenerator::EmitCallWithIC(Call* expr, RelocInfo::Mode reloc_info) {
+  // Code common for calls using the IC.
   ZoneList<Expression*>* args = expr->arguments();
-  Variable* var = fun->AsVariableProxy()->AsVariable();
-  ASSERT(var != NULL && !var->is_this() && var->is_global());
-  ASSERT(!var->is_possibly_eval());
-
-  __ push(Immediate(var->name()));
-  // Push global object (receiver).
-  __ push(CodeGenerator::GlobalObject());
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
     ASSERT_EQ(Expression::kValue, args->at(i)->context());
   }
-  // Record source position for debugger
+  // Record source position for debugger.
   SetSourcePosition(expr->position());
   // Call the IC initialization code.
   Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
                                                          NOT_IN_LOOP);
-  __ call(ic, RelocInfo::CODE_TARGET_CONTEXT);
+  __ call(ic, reloc_info);
   // Restore context register.
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
   // Discard the function left on TOS.
   DropAndMove(expr->context(), eax);
 }
 
 
+void FastCodeGenerator::EmitCallWithStub(Call* expr) {
+  // Code common for calls using the call stub.
+  ZoneList<Expression*>* args = expr->arguments();
+  int arg_count = args->length();
+  for (int i = 0; i < arg_count; i++) {
+    Visit(args->at(i));
+  }
+  // Record source position for debugger.
+  SetSourcePosition(expr->position());
+  CallFunctionStub stub(arg_count, NOT_IN_LOOP);
+  __ CallStub(&stub);
+  // Restore context register.
+  __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
+  // Discard the function left on TOS.
+  DropAndMove(expr->context(), eax);
+}
+
+
+void FastCodeGenerator::VisitCall(Call* expr) {
+  Expression* fun = expr->expression();
+
+  if (fun->AsProperty() != NULL) {
+    // Call on a property.
+    Property* prop = fun->AsProperty();
+    Literal* key = prop->key()->AsLiteral();
+    if (key != NULL && key->handle()->IsSymbol()) {
+      // Call on a named property: foo.x(1,2,3)
+      __ push(Immediate(key->handle()));
+      Visit(prop->obj());
+      // Use call IC.
+      EmitCallWithIC(expr, RelocInfo::CODE_TARGET);
+    } else {
+      // Call on a keyed property: foo[key](1,2,3)
+      // Use a keyed load IC followed by a call IC.
+      Visit(prop->obj());
+      Visit(prop->key());
+      // Record source position of property.
+      SetSourcePosition(prop->position());
+      Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
+      __ call(ic, RelocInfo::CODE_TARGET);
+      // By emitting a nop we make sure that we do not have a "test eax,..."
+      // instruction after the call it is treated specially by the LoadIC code.
+      __ nop();
+      // Drop key left on the stack by IC.
+      __ add(Operand(esp), Immediate(kPointerSize));
+      // Pop receiver.
+      __ pop(ebx);
+      // Push result (function).
+      __ push(eax);
+      // Push receiver object on stack.
+      if (prop->is_synthetic()) {
+        __ push(CodeGenerator::GlobalObject());
+      } else {
+        __ push(ebx);
+      }
+      EmitCallWithStub(expr);
+    }
+  } else if (fun->AsVariableProxy()->AsVariable() != NULL) {
+    // Call on a global variable
+    Variable* var = fun->AsVariableProxy()->AsVariable();
+    ASSERT(var != NULL && !var->is_this() && var->is_global());
+    ASSERT(!var->is_possibly_eval());
+    __ push(Immediate(var->name()));
+    // Push global object (receiver).
+    __ push(CodeGenerator::GlobalObject());
+    EmitCallWithIC(expr, RelocInfo::CODE_TARGET_CONTEXT);
+  } else {
+    // Calls we cannot handle right now.
+    // Should bailout in the CodeGenSelector.
+    UNREACHABLE();
+  }
+}
+
 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 169 matching lines @@
   }
   // Save or discard the right-hand value as needed.
   Visit(right);
   ASSERT_EQ(context, right->context());
 
   __ bind(&done);
 }
 
 
 } }  // namespace v8::internal