Fix issue 67 by copying the receiver function one slot

src/builtins-arm.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 252 matching lines @@
   // r0: actual number of argument
   { Label done;
     __ tst(r0, Operand(r0));
     __ b(ne, &done);
     __ mov(r2, Operand(Factory::undefined_value()));
     __ push(r2);
     __ add(r0, r0, Operand(1));
     __ bind(&done);
   }
 
-  // 2. Get the function to call. Already in r1.
+  // 2. Get the function to call from the stack.
   // r0: actual number of argument
   { Label done, non_function, function;
     __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2));
     __ tst(r1, Operand(kSmiTagMask));
     __ b(eq, &non_function);
     __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset));
     __ ldrb(r2, FieldMemOperand(r2, Map::kInstanceTypeOffset));
     __ cmp(r2, Operand(JS_FUNCTION_TYPE));
     __ b(eq, &function);
 
@@ skipping 69 matching lines @@
 
     __ bind(&done);
   }
 
   // 4. Shift stuff one slot down the stack
   // r0: actual number of arguments (including call() receiver)
   // r1: function
   { Label loop;
     // Calculate the copy start address (destination). Copy end address is sp.
     __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2));
+    __ add(r2, r2, Operand(kPointerSize));  // copy receiver too
 
     __ bind(&loop);
     __ ldr(ip, MemOperand(r2, -kPointerSize));
     __ str(ip, MemOperand(r2));
     __ sub(r2, r2, Operand(kPointerSize));
     __ cmp(r2, sp);
     __ b(ne, &loop);
   }
 
   // 5. Adjust the actual number of arguments and remove the top element.
   // r0: actual number of arguments (including call() receiver)
   // r1: function
   __ sub(r0, r0, Operand(1));
   __ add(sp, sp, Operand(kPointerSize));
 
   // 6. Get the code for the function or the non-function builtin.
   //    If number of expected arguments matches, then call. Otherwise restart
   //    the arguments adaptor stub.
   // r0: actual number of arguments
   // r1: function
   { Label invoke;
     __ tst(r1, r1);
     __ b(ne, &invoke);
-    // __ stop("Generate_ArgumentsAdaptorTrampoline - non-function call");
     __ mov(r2, Operand(0));  // expected arguments is 0 for CALL_NON_FUNCTION
     __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
     __ Jump(Handle<Code>(builtin(ArgumentsAdaptorTrampoline)), code_target);
 
     __ bind(&invoke);
     __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
     __ ldr(r2,
            FieldMemOperand(r3,
                            SharedFunctionInfo::kFormalParameterCountOffset));
     __ ldr(r3,
@@ skipping 431 matching lines @@
 }
 
 void Builtins::Generate_StubNoRegisters_DebugBreak(MacroAssembler* masm) {
   // Generate nothing as CodeStub CallFunction is not used on ARM.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal