Direct call api functions (arm implementation)

src/arm/macro-assembler-arm.cc

 // Copyright 2010 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 1379 matching lines @@
   Call(stub->GetCode(), RelocInfo::CODE_TARGET, cond);
 }
 
 
 void MacroAssembler::TailCallStub(CodeStub* stub, Condition cond) {
   ASSERT(allow_stub_calls());  // stub calls are not allowed in some stubs
   Jump(stub->GetCode(), RelocInfo::CODE_TARGET, cond);
 }
 
 
+MaybeObject* MacroAssembler::TryTailCallStub(CodeStub* stub, Condition cond) {
+  ASSERT(allow_stub_calls());  // stub calls are not allowed in some stubs
+  Object* result;
+  { MaybeObject* maybe_result = stub->TryGetCode();
+    if (!maybe_result->ToObject(&result)) return maybe_result;
+  }
+  Jump(stub->GetCode(), RelocInfo::CODE_TARGET, cond);
+  return result;
+}
+
+void MacroAssembler::PrepareCallApiFunction(int arg_stack_space,
+                                            int unwind_space) {
+  // Create the exit frame.
+  // +- caller pc -+- sp on exit -+- caller fp -+- code object -+-
+  // +- marker -+- exit frame sp -+- stack grows here -+-
+  add(ip, sp, Operand(unwind_space * kPointerSize));
+  stm(db_w, sp, fp.bit() | ip.bit() | lr.bit());
+  mov(fp, Operand(sp));
+
+  mov(ip, Operand(CodeObject()));
+  push(ip);
+  mov(ip, Operand(ExitApiFrameConstants::kMarker));
+  push(ip);
+  push(ip);  // Exit Frame sp patched before call.
+
+  mov(ip, Operand(ExternalReference(Top::k_c_entry_fp_address)));
+  str(fp, MemOperand(ip));
+  mov(ip, Operand(ExternalReference(Top::k_context_address)));
+  str(cp, MemOperand(ip));
+
+  // Create space for the arguments below the exit frame.
+  // +- exit frame -+- arguments -+- stack grows here -+
+  sub(sp, sp, Operand(arg_stack_space * kPointerSize));
+}
+
+static int AddressOffset(ExternalReference ref0, ExternalReference ref1) {
+  int64_t offset = (ref0.address() - ref1.address());
+  // Check that fits into int.
+  ASSERT(static_cast<int>(offset) == offset);
+  return static_cast<int>(offset);
+}
+
+MaybeObject* MacroAssembler::TryCallApiFunctionAndReturn(
+    ApiFunction* function) {
+  ExternalReference next_address =
+      ExternalReference::handle_scope_next_address();
+  const int kNextOffset = 0;
+  const int kLimitOffset = AddressOffset(
+      ExternalReference::handle_scope_limit_address(),
+      next_address);
+  const int kLevelOffset = AddressOffset(
+      ExternalReference::handle_scope_level_address(),
+      next_address);
+
+  // Allocate HandleScope in callee-save registers.
+  mov(r7, Operand(next_address));
+  ldr(r4, MemOperand(r7, kNextOffset));
+  ldr(r5, MemOperand(r7, kLimitOffset));
+  ldr(r6, MemOperand(r7, kLevelOffset));
+  add(r6, r6, Operand(1));
+  str(r6, MemOperand(r7, kLevelOffset));
+
+  // Create one slot for the return address to be pushed later
+  // and align the stack.
+  int frame_alignment = ActivationFrameAlignment();

[SeRya, 2011/01/20 12:09:28]

Currently CEntryStub stack layout is following:
<caller stack frame>
<stack alignment place holder initialized by 0?>
<caller frame pointer>
<caller stack pointer after unwinding>
<return address>
<code object>
<return address to the stub or 0-marker>
<fp state?>

Your layout:
<caller stack frame>
<caller frame pointer>
<caller stack pointer after unwinding>
<1-marker>
<pointer to the return address>
<stack alignment uninitialized place holder?>
<return address>
<code object>
<return address>

You can just move the stack alignment place holder above, initialize it by 0,
move the maker and pointer to the return address and your layout will be fully
compatible with CEntryStub. You won't need a special case in
ExitFrame::ComputeStackPointer and ExitApiFrameConstants.

Actually I think you should MacroAssembler::EnterExitFrame. Just move the
following lines out of the methods and it will do exactly what do you need here:

  add(ip, sp, Operand(r0, LSL, kPointerSizeLog2));
  sub(r6, ip, Operand(kPointerSize));
...
 // Setup argc and the builtin function in callee-saved registers.
  mov(r4, Operand(r0));
  mov(r5, Operand(r1));

[Zaheer, 2011/01/20 13:23:51]

Explaining the issue below, my layout in bit more detail
<caller stack frame>
<return address>
<caller stack pointer after unwinding>
<caller frame pointer> 
<code object> <-- centry sp, cant use the same in current case
<marker> 
<exit frame sp> 
.
.
<arguments>
.
.
<stack alignment>
<return address>
<native call stack>

I cannot completely reuse the exit frame layout since arguments come in between
exit frame and the native entry and hence the need to put additional slot
(marker/stack) to point to return address.

If you already considered the above issue, maybe i miss your point.
 initialize it by 0,
I think i can reuse EnterExitFrame by moving the code you mentioned below and
also making frame alignment code generic.

You won't need a special case in
From above comments iam not sure how to avoid this.
you mean i should move these back to CEntryStub::Generate and introduce a
parameter (say pending_push) which is used to do frame alignment.

[SeRya, 2011/01/20 15:18:47]

the placeholder above arguments.
Sorry, I forget about the arguments. But it's possible anyway to come to the
compatible layout. In contrast with ia32/x64 return address don't forced to be
on top of the stack. Lets put in in a fixed place instead of stack top:

1. Reserve room for the return address where it's expected to be in CEntryStub
(just before arguments): sub(sp, sp, Operand((arg_stack_space + 1) *
kPointerSize));
(for now there is the marker at this place, so it is not needed)
2. Don't push the return address, put it to that place:
  add(ip, pc, Operand(4));
  str(ip, MemOperand(fp, ExitFrameConstants::kSPOffset));
  Jump(r2);  // Call the api function.
3. In DirectCEntryStub::Generate use this slot to get real return address:
  ldr(ip, MemOperand(fp, ExitFrameConstants::kSPOffset));

[Zaheer, 2011/01/20 16:26:59]

Thanks. it does simplify it a lot.
Done
could you pls check, code object is stored at sp offset, i have introduced a new
constant kPCOffset which points to fp -2

+  int frame_alignment_mask = frame_alignment - 1;
+  if (frame_alignment > kPointerSize) {
+    ASSERT(frame_alignment == 2 * kPointerSize);
+    sub(sp, sp, Operand(1 * kPointerSize));
+    tst(sp, Operand(frame_alignment_mask));
+    // Stack alignment place holder need not be initialized as its below
+    // c_entry_fp_address and does not affect GC.
+    push(ip, nz);
+  } else {
+    sub(sp, sp, Operand(1 * kPointerSize));
+  }
+
+  // Store sp in the exit frame sp slot. sp - 1 points to return address
+  // pushed before call
+  add(sp, sp, Operand(1 * kPointerSize));
+  str(sp, MemOperand(fp, ExitApiFrameConstants::kSPOffset));

[SeRya, 2011/01/20 12:09:28]

It looks like this sequence is equal to the shorter one:

if (frame_alignment > kPointerSize) {
  ASSERT(frame_alignment == 2 * kPointerSize);
  tst(sp, Operand(frame_alignment_mask));
  // Stack alignment place holder need not be initialized as its below
  // c_entry_fp_address and does not affect GC.
  push(ip, eq);
}

// Store sp in the exit frame sp slot. sp - 1 points to return address
// pushed before call
str(sp, MemOperand(fp, ExitApiFrameConstants::kSPOffset));

(removed sub/add instructions and condition in the push instruction is changed
to the opposite one).

[Zaheer, 2011/01/20 13:23:51]

Thanks for the catch.

+
+  // Native call returns to the DirectCEntry stub which redirects to the
+  // return address pushed on stack (could have moved after GC).
+  DirectCEntryStub stub;
+  mov(lr, Operand(reinterpret_cast<intptr_t>(stub.GetCode().location()),
+                  RelocInfo::CODE_TARGET));
+
+  // Push return address (accessible to GC through exit frame pc).
+  mov(r2, Operand(reinterpret_cast<intptr_t>(function->address())));
+  add(ip, pc, Operand(4));
+  push(ip);
+  Jump(r2);  // Call the api function.
+
+  Label promote_scheduled_exception;
+  Label delete_allocated_handles;
+  Label leave_exit_frame;
+
+  // If result is non-zero, dereference to get the result value
+  // otherwise set it to undefined.
+  cmp(r0, Operand(0));
+  LoadRoot(r0, Heap::kUndefinedValueRootIndex, eq);
+  ldr(r0, MemOperand(r0), ne);
+
+  // No more valid handles (the result handle was the last one). Restore
+  // previous handle scope.
+  str(r4, MemOperand(r7, kNextOffset));
+  if (FLAG_debug_code) {
+    ldr(r1, MemOperand(r7, kLevelOffset));
+    cmp(r1, r6);
+    Check(eq, "Unexpected level after return from api call");
+  }
+  sub(r6, r6, Operand(1));
+  str(r6, MemOperand(r7, kLevelOffset));
+  ldr(ip, MemOperand(r7, kLimitOffset));
+  cmp(r5, ip);
+  b(ne, &delete_allocated_handles);
+
+  // Check if the function scheduled an exception.
+  bind(&leave_exit_frame);
+  LoadRoot(r4, Heap::kTheHoleValueRootIndex);
+  mov(ip, Operand(ExternalReference(Top::k_pending_exception_address)));
+  ldr(r5, MemOperand(ip));
+  cmp(r4, r5);
+  b(ne, &promote_scheduled_exception);
+  LeaveExitFrame(false);
+
+  bind(&promote_scheduled_exception);
+  MaybeObject* result = TryTailCallExternalReference(
+      ExternalReference(Runtime::kPromoteScheduledException), 0, 1);
+  if (result->IsFailure()) {
+    return result;
+  }
+
+  // HandleScope limit has changed. Delete allocated extensions.
+  bind(&delete_allocated_handles);
+  str(r5, MemOperand(r7, kLimitOffset));
+  mov(r4, r0);
+  PrepareCallCFunction(0, r5);
+  CallCFunction(ExternalReference::delete_handle_scope_extensions(), 0);
+  mov(r0, r4);
+  jmp(&leave_exit_frame);
+
+  return result;
+}
+
+
 void MacroAssembler::IllegalOperation(int num_arguments) {
   if (num_arguments > 0) {
     add(sp, sp, Operand(num_arguments * kPointerSize));
   }
   LoadRoot(r0, Heap::kUndefinedValueRootIndex);
 }
 
 
 void MacroAssembler::IndexFromHash(Register hash, Register index) {
   // If the hash field contains an array index pick it out. The assert checks
@@ skipping 232 matching lines @@
                                                int num_arguments,
                                                int result_size) {
   // TODO(1236192): Most runtime routines don't need the number of
   // arguments passed in because it is constant. At some point we
   // should remove this need and make the runtime routine entry code
   // smarter.
   mov(r0, Operand(num_arguments));
   JumpToExternalReference(ext);
 }
 
+MaybeObject* MacroAssembler::TryTailCallExternalReference(
+    const ExternalReference& ext, int num_arguments, int result_size) {
+  // TODO(1236192): Most runtime routines don't need the number of
+  // arguments passed in because it is constant. At some point we
+  // should remove this need and make the runtime routine entry code
+  // smarter.
+  mov(r0, Operand(num_arguments));
+  return TryJumpToExternalReference(ext);
+}
 
 void MacroAssembler::TailCallRuntime(Runtime::FunctionId fid,
                                      int num_arguments,
                                      int result_size) {
   TailCallExternalReference(ExternalReference(fid), num_arguments, result_size);
 }
 
 
 void MacroAssembler::JumpToExternalReference(const ExternalReference& builtin) {
 #if defined(__thumb__)
   // Thumb mode builtin.
   ASSERT((reinterpret_cast<intptr_t>(builtin.address()) & 1) == 1);
 #endif
   mov(r1, Operand(builtin));
   CEntryStub stub(1);
   Jump(stub.GetCode(), RelocInfo::CODE_TARGET);
 }
 
+MaybeObject* MacroAssembler::TryJumpToExternalReference(
+    const ExternalReference& builtin) {
+#if defined(__thumb__)
+  // Thumb mode builtin.
+  ASSERT((reinterpret_cast<intptr_t>(builtin.address()) & 1) == 1);
+#endif
+  mov(r1, Operand(builtin));
+  CEntryStub stub(1);
+  return TryTailCallStub(&stub);
+}
 
 void MacroAssembler::InvokeBuiltin(Builtins::JavaScript id,
                                    InvokeJSFlags flags) {
   GetBuiltinEntry(r2, id);
   if (flags == CALL_JS) {
     Call(r2);
   } else {
     ASSERT(flags == JUMP_JS);
     Jump(r2);
   }
@@ skipping 465 matching lines @@
 
 void CodePatcher::Emit(Address addr) {
   masm()->emit(reinterpret_cast<Instr>(addr));
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM