Avoiding repacking payload for v8::Arguments and v8::AccessorInfo (arm).

src/arm/stub-cache-arm.cc

 // Copyright 2006-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 589 matching lines @@
   JSFunction* function = optimization.constant_function();
   __ mov(r7, Operand(Handle<JSFunction>(function)));
   __ ldr(cp, FieldMemOperand(r7, JSFunction::kContextOffset));
 
   // Pass the additional arguments FastHandleApiCall expects.
   bool info_loaded = false;
   Object* callback = optimization.api_call_info()->callback();
   if (Heap::InNewSpace(callback)) {
     info_loaded = true;
     __ Move(r0, Handle<CallHandlerInfo>(optimization.api_call_info()));
-    __ ldr(r6, FieldMemOperand(r0, CallHandlerInfo::kCallbackOffset));
+    __ ldr(r5, FieldMemOperand(r0, CallHandlerInfo::kCallbackOffset));
   } else {
-    __ Move(r6, Handle<Object>(callback));
+    __ Move(r5, Handle<Object>(callback));
   }
   Object* call_data = optimization.api_call_info()->data();
   if (Heap::InNewSpace(call_data)) {
     if (!info_loaded) {
       __ Move(r0, Handle<CallHandlerInfo>(optimization.api_call_info()));
     }
-    __ ldr(r5, FieldMemOperand(r0, CallHandlerInfo::kDataOffset));
+    __ ldr(r6, FieldMemOperand(r0, CallHandlerInfo::kDataOffset));
   } else {
-    __ Move(r5, Handle<Object>(call_data));
+    __ Move(r6, Handle<Object>(call_data));
   }
 
   __ add(sp, sp, Operand(1 * kPointerSize));
   __ stm(ia, sp, r5.bit() | r6.bit() | r7.bit());
   __ sub(sp, sp, Operand(1 * kPointerSize));
 
   // Set the number of arguments.
   __ mov(r0, Operand(argc + 4));
 
   // Jump to the fast api call builtin (tail call).
@@ skipping 442 matching lines @@
   // Check that the receiver isn't a smi.
   __ tst(receiver, Operand(kSmiTagMask));
   __ b(eq, miss);
 
   // Check that the maps haven't changed.
   Register reg =
       CheckPrototypes(object, receiver, holder, scratch1, scratch2, scratch3,
                       name, miss);
 
   // Push the arguments on the JS stack of the caller.
-  __ push(receiver);  // Receiver.
-  __ push(reg);  // Holder.
+  __ push(receiver);  // Receiver

[antonm, 2010/11/17 14:10:32]

nit: probably change R -> r as you remove a dot.

[SeRya, 2010/11/17 15:36:29]

Reverted change in this line.

   __ mov(ip, Operand(Handle<AccessorInfo>(callback)));  // callback data

[antonm, 2010/11/17 14:10:32]

why such a change, __ Push(reg, ip, name_reg) apparently should have done the
trick, what am I missing

[SeRya, 2010/11/17 15:36:29]

It would work, but generates more instructions. |Push| preferes arguments with
decreasing codes. ip=r13, scratch3=r4, name_reg=r0|r2. So here are 2 decreasing
subsequences. Actually I was wrong (thought it needs increasing codes) and now
fixing.

-  __ ldr(reg, FieldMemOperand(ip, AccessorInfo::kDataOffset));
-  __ Push(ip, reg, name_reg);
+  __ ldr(scratch3, FieldMemOperand(ip, AccessorInfo::kDataOffset));
+  __ Push(reg, scratch3, ip);
+  __ push(name_reg);
 
   // Do tail-call to the runtime system.
   ExternalReference load_callback_property =
       ExternalReference(IC_Utility(IC::kLoadCallbackProperty));
   __ TailCallExternalReference(load_callback_property, 5, 1);
 
   return true;
 }
 
 
@@ skipping 102 matching lines @@
       ASSERT(callback != NULL);
       ASSERT(callback->getter() != NULL);
 
       // Tail call to runtime.
       // Important invariant in CALLBACKS case: the code above must be
       // structured to never clobber |receiver| register.
       __ Move(scratch2, Handle<AccessorInfo>(callback));
       // holder_reg is either receiver or scratch1.
       if (!receiver.is(holder_reg)) {
         ASSERT(scratch1.is(holder_reg));
-        __ Push(receiver, holder_reg, scratch2);
-        __ ldr(scratch1,
+        __ ldr(scratch3,

[antonm, 2010/11/17 14:10:32]

why scratch3?  it looks like the diff might be made easier to read by something
like:

__ Push(receiver, holder_reg);
__ ldr(....)
__ Push(.......)

[SeRya, 2010/11/17 15:36:29]

Done.

                FieldMemOperand(holder_reg, AccessorInfo::kDataOffset));
-        __ Push(scratch1, name_reg);
+        __ Push(receiver, holder_reg, scratch3);
+        __ Push(scratch2, name_reg);
       } else {
         __ push(receiver);
         __ ldr(scratch1,
                FieldMemOperand(holder_reg, AccessorInfo::kDataOffset));
-        __ Push(holder_reg, scratch2, scratch1, name_reg);
+        __ Push(holder_reg, scratch1, scratch2, name_reg);
       }
 
       ExternalReference ref =
           ExternalReference(IC_Utility(IC::kLoadCallbackProperty));
       __ TailCallExternalReference(ref, 5, 1);
     }
   } else {  // !compile_followup_inline
     // Call the runtime system to load the interceptor.
     // Check that the maps haven't changed.
     Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
@@ skipping 1515 matching lines @@
   // Return the generated code.
   return GetCode();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM