Fast-codegen: Added support for arguments in functions.

src/x64/fast-codegen-x64.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 44 matching lines @@
   function_ = fun;
   SetFunctionPosition(fun);
 
   __ push(rbp);  // Caller's frame pointer.
   __ movq(rbp, rsp);
   __ push(rsi);  // Callee's context.
   __ push(rdi);  // 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++) {
-      __ PushRoot(Heap::kUndefinedValueRootIndex);
+    if (locals_count <= 1) {
+      if (locals_count > 0) {
+        __ PushRoot(Heap::kUndefinedValueRootIndex);
+      }
+    } else {
+      __ LoadRoot(rdx, Heap::kUndefinedValueRootIndex);
+      for (int i = 0; i < locals_count; i++) {
+        __ push(rdx);
+      }
     }
   }
 
+  bool function_in_register = true;
+
+  Variable* arguments = fun->scope()->arguments()->AsVariable();
+  if (arguments != NULL) {
+    // Function uses arguments object.
+    Comment cmnt(masm_, "[ Allocate arguments object");
+    __ push(rdi);
+    // Receiver is located above the frame pointer, return address and

[William Hesse, 2009/11/12 09:56:49]

I think we would say "below" here.  Instead, say that the receiver is parameter
0, to avoid the issue.  Do we have a ParameterOperand(0) function?

[Lasse Reichstein, 2009/11/13 08:54:37]

Using "above" and "below" wrt stacks is the stuff religious wars are started
over. Rephrasing completely is probably better.
The same probably goes for parameter numbering (I'd say parameters are counted
from 0, so the receiver is parameter -1).
I think I'll go for "before the parameters on the stack".
We don't have a ParameterOperand, probably since it will require the number of
parameters as an argument as well, which reduces its immediate appeal).

+    // parameters.
+    __ lea(rdx, Operand(rbp, (fun->num_parameters() + 2) * kPointerSize));
+    __ push(rdx);
+    __ Push(Smi::FromInt(fun->num_parameters()));
+    // Arguments to ArgumentsAccessStub:
+    //   function, receiver address, parameter count.
+    // The stub will rewrite receiever and parameter count if the previous

[William Hesse, 2009/11/12 09:56:49]

receiver

[Lasse Reichstein, 2009/11/13 08:54:37]

fixed

+    // stack frame was an arguments adapter frame.
+    ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
+    __ CallStub(&stub);
+    Slot* arguments_slot = arguments->slot();

[William Hesse, 2009/11/12 09:56:49]

This variable name isn't much shorter than the expression it replaces, and it is
used only once.

And why don't we have a SlotOperand function?

[Lasse Reichstein, 2009/11/13 08:54:37]

I'll inline it.
We probably don't have the SlotOperand function because it would need to go in
the macro-assembler (because its return type is Operand on intel and MemOperand
on ARM), but it would require the code of SlotOffset which resides in codegen.
maybe we could move SlotOffset to the macro assembler(s) as well.

+    __ movq(Operand(rbp, SlotOffset(arguments_slot)), rax);
+    Slot* dot_arguments_slot =
+        fun->scope()->arguments_shadow()->AsVariable()->slot();
+    __ movq(Operand(rbp, SlotOffset(dot_arguments_slot)), rax);
+    function_in_register = false;
+  }
+
   // Possibly allocate a local context.
   if (fun->scope()->num_heap_slots() > 0) {
     Comment cmnt(masm_, "[ Allocate local context");
-    // Argument to NewContext is the function, still in rdi.
-    __ push(rdi);
+    if (function_in_register) {
+      // Argument to NewContext is the function, still in rdi.
+      __ push(rdi);
+    } else {
+      // Argument to NewContext is the function, no longer in rdi.
+      __ push(Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
+    }
     __ CallRuntime(Runtime::kNewContext, 1);
     // Context is returned in both rax and rsi.  It replaces the context
     // passed to us.  It's saved in the stack and kept live in rsi.
     __ movq(Operand(rbp, StandardFrameConstants::kContextOffset), rsi);
 #ifdef DEBUG
     // Assert we do not have to copy any parameters into the context.
     for (int i = 0, len = fun->scope()->num_parameters(); i < len; i++) {
       Slot* slot = fun->scope()->parameter(i)->slot();
       ASSERT(slot != NULL && slot->type() != Slot::CONTEXT);
     }
@@ skipping 340 matching lines @@
     __ push(CodeGenerator::GlobalObject());
     __ Move(rcx, expr->name());
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     // A test rax instruction following the call is used by the IC to
     // indicate that the inobject property case was inlined.  Ensure there
     // is no test rax instruction here.
     __ nop();
 
     DropAndMove(expr->context(), rax);
-  } else {
+  } else if (rewrite->AsSlot() != NULL) {
     Slot* slot = rewrite->AsSlot();
-    ASSERT_NE(NULL, slot);
     switch (slot->type()) {
       case Slot::LOCAL:
       case Slot::PARAMETER: {
         Comment cmnt(masm_, "Stack slot");
         Move(expr->context(), slot);
         break;
       }
 
       case Slot::CONTEXT: {
         Comment cmnt(masm_, "Context slot");
@@ skipping 20 matching lines @@
         }
         __ movq(rax, Operand(rax, Context::SlotOffset(slot->index())));
         Move(expr->context(), rax);
         break;
       }
 
       case Slot::LOOKUP:
         UNREACHABLE();
         break;
     }
+  } else {
+    // The parameter variable has been rewritten into an explict access to
+    // the arguments object.
+    Property* property = rewrite->AsProperty();
+    ASSERT_NOT_NULL(property);
+    ASSERT_EQ(expr->context(), property->context());
+    Visit(property);
   }
 }
 
 
 void FastCodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
   Comment cmnt(masm_, "[ RegExpLiteral");
   Label done;
   // Registers will be used as follows:
   // rdi = JS function.
   // rbx = literals array.
@@ skipping 1015 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal