Get rid of unnecessary handle management when invoking 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 134 matching lines @@
 
   // Probe the secondary table.
   ProbeTable(masm, flags, kSecondary, name, scratch, extra);
 
   // Cache miss: Fall-through and let caller handle the miss by
   // entering the runtime system.
   __ bind(&miss);
 }
 
 
+template <typename Pushable>
+static void PushInterceptorArguments(MacroAssembler* masm,
+                                     Register receiver,
+                                     Register holder,
+                                     Pushable name,
+                                     JSObject* holder_obj,
+                                     Smi* lookup_hint) {
+  __ push(receiver);
+  __ push(holder);
+  __ push(name);
+  // TODO(367): Maybe don't push lookup_hint for LOOKUP_IN_HOLDER and/or
+  // LOOKUP_IN_PROTOTYPE, but use a special version of lookup method?
+  __ push(Immediate(lookup_hint));
+
+  InterceptorInfo* interceptor = holder_obj->GetNamedInterceptor();
+  __ mov(receiver, Immediate(Handle<Object>(interceptor)));
+  __ push(receiver);
+  __ push(FieldOperand(receiver, InterceptorInfo::kDataOffset));
+}
+
+
 void StubCompiler::GenerateLoadGlobalFunctionPrototype(MacroAssembler* masm,
                                                        int index,
                                                        Register prototype) {
   // Load the global or builtins object from the current context.
   __ mov(prototype, Operand(esi, Context::SlotOffset(Context::GLOBAL_INDEX)));
   // Load the global context from the global or builtins object.
   __ mov(prototype,
          FieldOperand(prototype, GlobalObject::kGlobalContextOffset));
   // Load the function from the global context.
   __ mov(prototype, Operand(prototype, Context::SlotOffset(index)));
@@ skipping 332 matching lines @@
   __ test(receiver, Immediate(kSmiTagMask));
   __ j(zero, miss, not_taken);
 
   // Check that the maps haven't changed.
   Register reg =
       CheckPrototypes(object, receiver, holder,
                       scratch1, scratch2, name, miss);
 
   // Push the arguments on the JS stack of the caller.
   __ pop(scratch2);  // remove return address
-  __ push(receiver);  // receiver
-  __ push(reg);  // holder
-  __ push(name_reg);  // name
-  // TODO(367): Maybe don't push lookup_hint for LOOKUP_IN_HOLDER and/or
-  // LOOKUP_IN_PROTOTYPE, but use a special version of lookup method?
-  __ push(Immediate(lookup_hint));
+  PushInterceptorArguments(masm(),
+                           receiver,
+                           reg,
+                           name_reg,
+                           holder,
+                           lookup_hint);
   __ push(scratch2);  // restore return address
 
   // Do tail-call to the runtime system.
   ExternalReference load_ic_property =
       ExternalReference(IC_Utility(IC::kLoadInterceptorProperty));
-  __ TailCallRuntime(load_ic_property, 4);
+  __ TailCallRuntime(load_ic_property, 6);
 }
 
 
 // TODO(1241006): Avoid having lazy compile stubs specialized by the
 // number of arguments. It is not needed anymore.
 Object* StubCompiler::CompileLazyCompile(Code::Flags flags) {
   // Enter an internal frame.
   __ EnterInternalFrame();
 
   // Push a copy of the function onto the stack.
@@ skipping 208 matching lines @@
 
   // Check that maps have not changed and compute the holder register.
   Register reg =
       CheckPrototypes(JSObject::cast(object), edx, holder,
                       ebx, ecx, name, &miss);
 
   // Enter an internal frame.
   __ EnterInternalFrame();
 
   // Push arguments on the expression stack.
-  __ push(edx);  // receiver
-  __ push(reg);  // holder
-  __ push(Operand(ebp, (argc + 3) * kPointerSize));  // name
-  __ push(Immediate(holder->InterceptorPropertyLookupHint(name)));
+  PushInterceptorArguments(masm(),
+                           edx,
+                           reg,
+                           Operand(ebp, (argc + 3) * kPointerSize),
+                           holder,
+                           holder->InterceptorPropertyLookupHint(name));
 
   // Perform call.
   ExternalReference load_interceptor =
       ExternalReference(IC_Utility(IC::kLoadInterceptorProperty));
-  __ mov(eax, Immediate(4));
+  __ mov(eax, Immediate(6));
   __ mov(ebx, Immediate(load_interceptor));
 
   CEntryStub stub;
   __ CallStub(&stub);
 
   // Move result to edi and restore receiver.
   __ mov(edi, eax);
   __ mov(edx, Operand(ebp, (argc + 2) * kPointerSize));  // receiver
 
   // Exit frame.
@@ skipping 664 matching lines @@
   GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC);
 
   // Return the generated code.
   return GetCode(CALLBACKS, name);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal