Simplify passing of AccessorInfo to interceptors:

src/ia32/stub-cache-ia32.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 258 matching lines @@
     __ mov(dst, FieldOperand(dst, offset));
   }
 }
 
 
 static void PushInterceptorArguments(MacroAssembler* masm,
                                      Register receiver,
                                      Register holder,
                                      Register name,
                                      JSObject* holder_obj) {
-  __ push(receiver);
-  __ push(holder);
   __ push(name);
   InterceptorInfo* interceptor = holder_obj->GetNamedInterceptor();
   ASSERT(!Heap::InNewSpace(interceptor));
-  __ mov(receiver, Immediate(Handle<Object>(interceptor)));
+  Register scratch = name;
+  __ mov(scratch, Immediate(Handle<Object>(interceptor)));
+  __ push(scratch);
   __ push(receiver);
-  __ push(FieldOperand(receiver, InterceptorInfo::kDataOffset));
+  __ push(holder);
+  __ push(FieldOperand(scratch, InterceptorInfo::kDataOffset));
 }
 
 
 static void CompileCallLoadPropertyWithInterceptor(MacroAssembler* masm,
                                                    Register receiver,
                                                    Register holder,
                                                    Register name,
                                                    JSObject* holder_obj) {
   PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
   __ CallExternalReference(
@@ skipping 735 matching lines @@
   Register reg =
       CheckPrototypes(object, receiver, holder,
                       scratch1, scratch2, name, miss);
 
   Handle<AccessorInfo> callback_handle(callback);
 
   Register other = reg.is(scratch1) ? scratch2 : scratch1;
   __ EnterInternalFrame();
   __ PushHandleScope(other);
   // Push the stack address where the list of arguments ends
   __ mov(other, esp);

[antonm, 2010/03/25 14:40:53]

Do we need to push the address?

[Vitaly Repeshko, 2010/03/25 17:08:56]

Yes, please see below. It's internal::Object** from AccessorInfo.

   __ sub(Operand(other), Immediate(2 * kPointerSize));
   __ push(other);
   __ push(receiver);  // receiver
   __ push(reg);  // holder
   __ mov(other, Immediate(callback_handle));
-  __ push(other);
   __ push(FieldOperand(other, AccessorInfo::kDataOffset));  // data
   __ push(name_reg);  // name
   // Save a pointer to where we pushed the arguments pointer.
-  // This will be passed as the const Arguments& to the C++ callback.
+  // This will be passed as the const AccessorInfo& to the C++ callback.
   __ mov(eax, esp);
-  __ add(Operand(eax), Immediate(5 * kPointerSize));
+  __ add(Operand(eax), Immediate(4 * kPointerSize));

[antonm, 2010/03/25 14:40:53]

could we use some named constant for this 4?

[Vitaly Repeshko, 2010/03/25 17:08:56]

This is a local thing: it's the depth of the arguments pointer as described in
the comment.

   __ mov(ebx, esp);
 
   // Do call through the api.
-  ASSERT_EQ(6, ApiGetterEntryStub::kStackSpace);
+  ASSERT_EQ(5, ApiGetterEntryStub::kStackSpace);

[antonm, 2010/03/25 14:40:53]

do you I understand it right, this is not ported to other platforms?  do you
know if we have corresponding bugs filed?

[Vitaly Repeshko, 2010/03/25 17:08:56]

Right, this is not ported to other platforms and I couldn't find a relevant bug.
Filed http://code.google.com/p/v8/issues/detail?id=663

   Address getter_address = v8::ToCData<Address>(callback->getter());
   ApiFunction fun(getter_address);
   ApiGetterEntryStub stub(callback_handle, &fun);
   // Emitting a stub call may try to allocate (if the code is not
   // already generated).  Do not allow the assembler to perform a
   // garbage collection but instead return the allocation failure
   // object.
   Object* result = masm()->TryCallStub(&stub);
   if (result->IsFailure()) {
     *failure = Failure::cast(result);
@@ skipping 1355 matching lines @@
   __ jmp(generic_construct_stub, RelocInfo::CODE_TARGET);
 
   // Return the generated code.
   return GetCode();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal