Implement DoApplyArguments.

src/arm/lithium-codegen-arm.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 1687 matching lines @@
   __ ldr(result,
          MemOperand(result, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ SmiUntag(result);
 
   // Argument length is in result register.
   __ bind(&done);
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
-  Abort("DoApplyArguments unimplemented.");
+  Register receiver = ToRegister(instr->receiver());
+  Register function = ToRegister(instr->function());
+  Register scratch = scratch0();
+
+  ASSERT(receiver.is(r0));
+  ASSERT(function.is(r1));
+  ASSERT(ToRegister(instr->result()).is(r0));
+
+  // If the receiver is null or undefined, we have to pass the
+  // global object as a receiver.
+  Label global_receiver, receiver_ok;
+  __ LoadRoot(scratch, Heap::kNullValueRootIndex);
+  __ cmp(receiver, scratch);
+  __ b(eq, &global_receiver);
+  __ LoadRoot(scratch, Heap::kUndefinedValueRootIndex);
+  __ cmp(receiver, scratch);
+  __ b(ne, &receiver_ok);
+  __ bind(&global_receiver);
+  __ ldr(receiver, GlobalObjectOperand());
+  __ bind(&receiver_ok);
+
+  Register length = ToRegister(instr->length());
+  Register elements = ToRegister(instr->elements());
+
+  Label invoke;
+
+  // Copy the arguments to this function possibly from the
+  // adaptor frame below it.
+  const uint32_t kArgumentsLimit = 1 * KB;
+  __ cmp(length, Operand(kArgumentsLimit));
+  DeoptimizeIf(hi, instr->environment());
+
+  __ push(receiver);
+  __ mov(receiver, length);

[Søren Thygesen Gjesse, 2011/01/11 12:01:28]

Please add a comment why we are adding 4 here, and use kPointerSize instead of
4.

[Karl Klose, 2011/01/11 13:04:33]

Done.

+  __ add(elements, elements, Operand(4));
+
+  // Loop through the arguments pushing them onto the execution
+  // stack.
+  Label loop;

[Søren Thygesen Gjesse, 2011/01/11 12:01:28]

I don't know if it will make a difference, but we have 4 free registers, so we
could use load/store multiple with 4 elements at the time after aligning length
by 0-3 initial load/stores by checking the two lower bit s of length.

[Karl Klose, 2011/01/11 13:04:33]

I do not see large numbers of arguments, so I did not change it.
On 2011/01/11 12:01:28, Søren Gjesse wrote:

+  // length is a small non-negative integer, due to the test above.
+  __ tst(length, Operand(length));
+  __ b(eq, &invoke);
+  __ bind(&loop);
+  __ ldr(scratch, MemOperand(elements, length, LSL, 2));
+  __ push(scratch);
+  __ sub(length, length, Operand(1), SetCC);
+  __ b(ne, &loop);
+
+  // Invoke the function.
+  __ bind(&invoke);
+  v8::internal::ParameterCount actual(receiver);

[Søren Thygesen Gjesse, 2011/01/11 12:01:28]

Maybe comment here that receiver stores the original count and is r0 which is
mandated by InvokeFunction.

[Karl Klose, 2011/01/11 13:04:33]

Done.

+
+  SafepointGenerator safepoint_generator(this,
+                                         instr->pointer_map(),
+                                         Safepoint::kNoDeoptimizationIndex);
+  __ InvokeFunction(function, actual, CALL_FUNCTION, &safepoint_generator);
 }
 
 
 void LCodeGen::DoPushArgument(LPushArgument* instr) {
   LOperand* argument = instr->input();
   if (argument->IsDoubleRegister() || argument->IsDoubleStackSlot()) {
     Abort("DoPushArgument not implemented for double type.");
   } else {
     Register argument_reg = EmitLoadRegister(argument, ip);
     __ push(argument_reg);
@@ skipping 878 matching lines @@
 
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("DoOsrEntry unimplemented.");
 }
 
 
 #undef __
 
 } }  // namespace v8::internal