Fix ABI for API calls on ia32.

src/ia32/macro-assembler-ia32.cc

 // Copyright 2011 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 1411 matching lines @@
     EnterApiExitFrame(argc + 2);
 
     // The argument slots are filled as follows:
     //
     //   n + 1: output cell
     //   n: arg n
     //   ...
     //   1: arg1
     //   0: pointer to the output cell
     //
-    // Note that this is one more "argument" than the function expects
-    // so the out cell will have to be popped explicitly after returning
-    // from the function. The out cell contains Handle.
 
     // pointer to out cell.
     lea(scratch, Operand(esp, (argc + 1) * kPointerSize));
     mov(Operand(esp, 0 * kPointerSize), scratch);  // output.
     if (emit_debug_code()) {
       mov(Operand(esp, (argc + 1) * kPointerSize), Immediate(0));  // out cell.
     }
   }
 }
 
 
 MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(ApiFunction* function,
+                                                         int argc,
                                                          int stack_space) {
   ExternalReference next_address =
       ExternalReference::handle_scope_next_address();
   ExternalReference limit_address =
       ExternalReference::handle_scope_limit_address();
   ExternalReference level_address =
       ExternalReference::handle_scope_level_address();
 
+  // Save out slot address in the callee-save register.

[Vitaly Repeshko, 2011/07/04 22:41:36]

Let's be consistent with "slot" vs. "cell" here in the function above. I prefer
"slot".

[Vyacheslav Egorov (Chromium), 2011/07/05 11:03:50]

Done.

+  if (!kReturnHandlesDirectly) {
+    lea(esi, Operand(esp, (argc + 1) * kPointerSize));

[Vitaly Repeshko, 2011/07/04 22:41:36]

This is tightly coupled to PrepareCallApiFunction. Its comments already
(incorrectly it seems) say it uses esi to restore the original stack state. How
about moving this block to PrepareCallApiFunction? This way we can avoid passing
the confusing argc here.
Also for debugging purposes it may be useful to clobber esi even if
kReturnHandlesDirectly is true (in debug mode).

[Vyacheslav Egorov (Chromium), 2011/07/05 11:03:50]

I though about that but did not want to prolong esi liverange. 

Done.

+  }
+
   // Allocate HandleScope in callee-save registers.
   mov(ebx, Operand::StaticVariable(next_address));
   mov(edi, Operand::StaticVariable(limit_address));
   add(Operand::StaticVariable(level_address), Immediate(1));
 
   // Call the api function!
   call(function->address(), RelocInfo::RUNTIME_ENTRY);
 
   if (!kReturnHandlesDirectly) {
-    // The returned value is a pointer to the handle holding the result.
-    // Dereference this to get to the location.
-    mov(eax, Operand(eax, 0));
+    mov(eax, Operand(esi, 0));

[Vitaly Repeshko, 2011/07/04 22:41:36]

Some comment here would be helpful.

[Vyacheslav Egorov (Chromium), 2011/07/05 11:03:50]

Done.

   }
 
   Label empty_handle;
   Label prologue;
   Label promote_scheduled_exception;
   Label delete_allocated_handles;
   Label leave_exit_frame;
 
   // Check if the result handle holds 0.
   test(eax, Operand(eax));
@@ skipping 654 matching lines @@
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32