Under construction: Preliminary change to support per...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 1161 matching lines @@
   int value_;
 };
 
 
 void SmiComparisonDeferred::Generate() {
   CompareStub stub(cc_, strict_);
   // Setup parameters and call stub.
   __ mov(edx, Operand(eax));
   __ mov(Operand(eax), Immediate(Smi::FromInt(value_)));
   __ CallStub(&stub);
-  __ cmp(eax, 0);
+  if (cc_ == equal) {
+    __ test(eax, Operand(eax));
+  } else {
+    __ cmp(eax, 0);
+  }
   // "result" is returned in the flags
 }
 
 
 void CodeGenerator::SmiComparison(Condition cc,
                                       Handle<Object> value,
                                       bool strict) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   int int_value = Smi::cast(*value)->value();
   ASSERT(is_intn(int_value, kMaxSmiInlinedBits));
 
   SmiComparisonDeferred* deferred =
       new SmiComparisonDeferred(this, cc, strict, int_value);
   __ pop(eax);
   __ test(eax, Immediate(kSmiTagMask));
   __ j(not_zero, deferred->enter(), not_taken);
   // Test smi equality by pointer comparison.
   __ cmp(Operand(eax), Immediate(value));
   __ bind(deferred->exit());
   cc_reg_ = cc;
 }
 
 
 class CallFunctionStub: public CodeStub {
  public:
-  explicit CallFunctionStub(int argc) : argc_(argc) { }
+  explicit CallFunctionStub(int argc, bool call_constructor)
+      : argc_(argc), call_constructor_(call_constructor) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   int argc_;
+  bool call_constructor_;
 
 #ifdef DEBUG
   void Print() { PrintF("CallFunctionStub (args %d)\n", argc_); }
 #endif
 
   Major MajorKey() { return CallFunction; }
-  int MinorKey() { return argc_; }
+  int MinorKey() { return (argc_ << 1) | (call_constructor_ ? 1 : 0); }
 };
 
 
 // Call the function just below TOS on the stack with the given
 // arguments. The receiver is the TOS.
 void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
-                                          int position) {
+                                      bool call_constructor,

[iposva, 2008/10/10 13:56:18]

Please change the bool parameter to an enum {FUNCTION, CONSTRUCTOR} to increase
readability at the call sites.

+                                      int position) {
   // Push the arguments ("left-to-right") on the stack.
   for (int i = 0; i < args->length(); i++) {
     Load(args->at(i));
   }
 
   // Record the position for debugging purposes.
   __ RecordPosition(position);
 
   // Use the shared code stub to call the function.
-  CallFunctionStub call_function(args->length());
-  __ CallStub(&call_function);
+  CallFunctionStub call_function(args->length(), call_constructor);
+  RelocInfo::Mode mode = call_constructor
+      ? RelocInfo::CONSTRUCT_CALL
+      : RelocInfo::CODE_TARGET;
+  __ CallStub(&call_function, mode);
 
   // Restore context and pop function from the stack.
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
   __ mov(TOS, eax);
 }
 
 
 void CodeGenerator::Branch(bool if_true, Label* L) {
   ASSERT(has_cc());
   Condition cc = if_true ? cc_reg_ : NegateCondition(cc_reg_);
@@ skipping 1339 matching lines @@
     __ push(Operand(esi));
     __ push(Immediate(var->name()));
     __ CallRuntime(Runtime::kLoadContextSlot, 2);
     // eax: slot value; edx: receiver
 
     // Load the receiver.
     __ push(eax);
     __ push(edx);
 
     // Call the function.
-    CallWithArguments(args, node->position());
+    CallWithArguments(args, false, node->position());
 
   } else if (property != NULL) {
     // Check if the key is a literal string.
     Literal* literal = property->key()->AsLiteral();
 
     if (literal != NULL && literal->handle()->IsSymbol()) {
       // ------------------------------------------------------------------
       // JavaScript example: 'object.foo(1, 2, 3)' or 'map["key"](1, 2, 3)'
       // ------------------------------------------------------------------
 
@@ skipping 20 matching lines @@
 
       // Load the function to call from the property through a reference.
       Reference ref(this, property);
       ref.GetValue(NOT_INSIDE_TYPEOF);
 
       // Pass receiver to called function.
       // The reference's size is non-negative.
       __ push(Operand(esp, ref.size() * kPointerSize));
 
       // Call the function.
-      CallWithArguments(args, node->position());
+      CallWithArguments(args, false, node->position());
     }
 
   } else {
     // ----------------------------------
     // JavaScript example: 'foo(1, 2, 3)'  // foo is not global
     // ----------------------------------
 
     // Load the function.
     Load(function);
 
     // Pass the global object as the receiver.
     LoadGlobal();
 
     // Call the function.
-    CallWithArguments(args, node->position());
+    CallWithArguments(args, false, node->position());
   }
 }
 
 
 void CodeGenerator::VisitCallNew(CallNew* node) {
   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. This is different from ordinary calls, where the
   // actual function to call is resolved after the arguments have been
   // evaluated.
 
   // Compute function to call and use the global object as the
   // receiver.
   Load(node->expression());
   LoadGlobal();
 
-  // Push the arguments ("left-to-right") on the stack.
-  ZoneList<Expression*>* args = node->arguments();
-  for (int i = 0; i < args->length(); 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.
-  __ Set(eax, Immediate(args->length()));
-
-  // Load the function into temporary function slot as per calling
-  // convention.
-  __ mov(edi, Operand(esp, (args->length() + 1) * kPointerSize));
-
-  // Call the construct call builtin that handles allocation and
-  // constructor invocation.
-  __ RecordPosition(node->position());
-  __ call(Handle<Code>(Builtins::builtin(Builtins::JSConstructCall)),
-          RelocInfo::CONSTRUCT_CALL);
-  __ mov(TOS, eax);  // discard the function and "push" the newly created object
+  CallWithArguments(node->arguments(), true, node->position());

[iposva, 2008/10/10 13:56:18]

Nice refactoring!

 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   Load(args->at(0));
   __ pop(eax);
   __ test(eax, Immediate(kSmiTagMask));
   cc_reg_ = zero;
 }
@@ skipping 1942 matching lines @@
   // Check that the function really is a JavaScript function.
   __ test(edi, Immediate(kSmiTagMask));
   __ j(zero, &slow, not_taken);
   // Get the map.
   __ mov(ecx, FieldOperand(edi, HeapObject::kMapOffset));
   __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
   __ cmp(ecx, JS_FUNCTION_TYPE);
   __ j(not_equal, &slow, not_taken);
 
   // Fast-case: Just invoke the function.
-  ParameterCount actual(argc_);
-  __ InvokeFunction(edi, actual, JUMP_FUNCTION);
+  if (call_constructor_) {
+    __ Set(eax, Immediate(argc_));
+    __ mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
+    __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
+    __ mov(edx, FieldOperand(edx, SharedFunctionInfo::kConstructorOffset));
+    __ lea(edx, FieldOperand(edx, Code::kHeaderSize));
+    __ jmp(Operand(edx));
+  } else {
+    ParameterCount actual(argc_);
+    __ InvokeFunction(edi, actual, JUMP_FUNCTION);
+  }
 
   // Slow-case: Non-function called.
   __ bind(&slow);
-  __ Set(eax, Immediate(argc_));
-  __ Set(ebx, Immediate(0));
-  __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
-  Handle<Code> adaptor(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline));
-  __ jmp(adaptor, RelocInfo::CODE_TARGET);
+  if (call_constructor_) {
+    // Get rid of the arguments and the receiver and call the NewObject
+    // runtime function to generate and throw an exception.
+    __ pop(ecx);
+    __ add(Operand(esp), Immediate((argc_ + 1) * kPointerSize));
+    __ push(ecx);
+    __ TailCallRuntime(ExternalReference(Runtime::kNewObject), 1);
+  } else {
+    __ Set(eax, Immediate(argc_));
+    __ Set(ebx, Immediate(0));
+    __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
+    Handle<Code> adaptor(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline));
+    __ jmp(adaptor, RelocInfo::CODE_TARGET);
+  }
 }
 
 
 void RevertToNumberStub::Generate(MacroAssembler* masm) {
   // Revert optimistic increment/decrement.
   if (is_increment_) {
     __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
   } else {
     __ add(Operand(eax), Immediate(Smi::FromInt(1)));
   }
@@ skipping 370 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal