Direct call api functions (arm implementation)

src/arm/frames-arm.h

 // Copyright 2006-2008 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 91 matching lines @@
 
 class EntryFrameConstants : public AllStatic {
  public:
   static const int kCallerFPOffset      = -3 * kPointerSize;
 };
 
 
 class ExitFrameConstants : public AllStatic {
  public:
   static const int kCodeOffset = -1 * kPointerSize;
   static const int kSPOffset = -1 * kPointerSize;

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

It's look strange for me that kSPOffset == kCodeOffset. We have the following
code:
EnterExitFrame:
  mov(ip, Operand(CodeObject()));
  push(ip);  // Accessed from ExitFrame::code_slot.

  // Save the frame pointer and the context in top.
  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));

  if (save_doubles) {
    mov(ip, Operand(0));  // Marker and alignment word.
    push(ip);
    ...
  }
CEntryStub::GenerateCore:
  masm->add(lr, pc, Operand(4));  // Compute return address: (pc + 8) + 4
  masm->push(lr);
  masm->Jump(r5);

As I see SPOffset shares its place with marker but not with the Code object.

In ia-32 they are different:
  static const int kCodeOffset      = -2 * kPointerSize;
  static const int kSPOffset        = -1 * kPointerSize;

If the return address is never fixed from GC (since the the CEntryStub is de
facto unmovable) it may explain why it doesn't crash.

 
   // TODO(regis): Use a patched sp value on the stack instead.
   // A marker of 0 indicates that double registers are saved.
   static const int kMarkerOffset = -2 * kPointerSize;
 
   // The caller fields are below the frame pointer on the stack.
   static const int kCallerFPOffset = +0 * kPointerSize;
   // The calling JS function is between FP and PC.
   static const int kCallerPCOffset = +2 * kPointerSize;
 
   // FP-relative displacement of the caller's SP.  It points just
   // below the saved PC.
   static const int kCallerSPDisplacement = +3 * kPointerSize;
 };
 
+class ExitApiFrameConstants : public AllStatic {
+ public:
+  static const int kSPOffset = -3 * kPointerSize;
+  static const int kMarker = 0x01;
+};
+
 
 class StandardFrameConstants : public AllStatic {
  public:
   static const int kExpressionsOffset = -3 * kPointerSize;
   static const int kMarkerOffset      = -2 * kPointerSize;
   static const int kContextOffset     = -1 * kPointerSize;
   static const int kCallerFPOffset    =  0 * kPointerSize;
   static const int kCallerPCOffset    = +1 * kPointerSize;
   static const int kCallerSPOffset    = +2 * kPointerSize;
 };
@@ skipping 26 matching lines @@
 
 inline Object* JavaScriptFrame::function_slot_object() const {
   const int offset = JavaScriptFrameConstants::kFunctionOffset;
   return Memory::Object_at(fp() + offset);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_FRAMES_ARM_H_