Refactored the code for entering and leaving exit frames (calls...

src/codegen-arm.cc

 // 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 1622 matching lines @@
                               bool do_restore) {
   // r0: result parameter for PerformGC, if any
   // r4: number of arguments including receiver  (C callee-saved)
   // r5: pointer to builtin function  (C callee-saved)
 
   if (do_gc) {
     __ Call(FUNCTION_ADDR(Runtime::PerformGC), runtime_entry);  // passing r0
   }
 
   // Call C built-in.
-  // r0 = argc.
+  // r0 = argc, r1 = argv
   __ mov(r0, Operand(r4));
-  // r1 = argv.
-  __ add(r1, fp, Operand(r4, LSL, kPointerSizeLog2));
-  __ add(r1, r1, Operand(ExitFrameConstants::kPPDisplacement - kPointerSize));
+  __ mov(r1, Operand(r6));

[iposva, 2008/09/23 07:51:28]

Please add r6 to the contract with calling code above.

 
   // TODO(1242173): To let the GC traverse the return address of the exit
   // frames, we need to know where the return address is. Right now,
   // we push it on the stack to be able to find it again, but we never
   // restore from it in case of changes, which makes it impossible to
   // support moving the C entry code stub. This should be fixed, but currently
   // this is OK because the CEntryStub gets generated so early in the V8 boot
   // sequence that it is not moving ever.
   __ add(lr, pc, Operand(4));  // compute return address: (pc + 8) + 4
   __ push(lr);
 #if !defined(__arm__)
   // Notify the simulator of the transition to C code.
   __ swi(assembler::arm::call_rt_r5);
 #else /* !defined(__arm__) */
   __ mov(pc, Operand(r5));
 #endif /* !defined(__arm__) */
   // result is in r0 or r0:r1 - do not destroy these registers!
 
   // check for failure result
   Label failure_returned;
   ASSERT(((kFailureTag + 1) & kFailureTagMask) == 0);
   // Lower 2 bits of r2 are 0 iff r0 has failure tag.
   __ add(r2, r0, Operand(1));
   __ tst(r2, Operand(kFailureTagMask));
   __ b(eq, &failure_returned);
 
-  // clear top frame
-  __ mov(r3, Operand(0));
-  __ mov(ip, Operand(ExternalReference(Top::k_c_entry_fp_address)));
-  __ str(r3, MemOperand(ip));
-
   // Restore the memory copy of the registers by digging them out from
   // the stack.
   if (do_restore) {
     // Ok to clobber r2 and r3.
     const int kCallerSavedSize = kNumJSCallerSaved * kPointerSize;
     const int kOffset = ExitFrameConstants::kDebugMarkOffset - kCallerSavedSize;
     __ add(r3, fp, Operand(kOffset));
     __ CopyRegistersFromStackToMemory(r3, r2, kJSCallerSaved);
   }
 
   // Exit C frame and return
   // r0:r1: result
   // sp: stack pointer
   // fp: frame pointer
   // pp: caller's parameter pointer pp  (restored as C callee-saved)
-
-  // Restore current context from top and clear it in debug mode.
-  __ mov(r3, Operand(Top::context_address()));
-  __ ldr(cp, MemOperand(r3));
-  __ mov(sp, Operand(fp));  // respect ABI stack constraint
-  __ ldm(ia, sp, fp.bit() | sp.bit() | pc.bit());
+  __ LeaveExitFrame();
 
   // check if we should retry or throw exception
   Label retry;
   __ bind(&failure_returned);
   ASSERT(Failure::RETRY_AFTER_GC == 0);
   __ tst(r0, Operand(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
   __ b(eq, &retry);
 
   Label continue_exception;
   // If the returned failure is EXCEPTION then promote Top::pending_exception().
@@ skipping 27 matching lines @@
   // fp: frame pointer  (restored after C call)
   // sp: stack pointer  (restored as callee's pp after C call)
   // cp: current context  (C callee-saved)
   // pp: caller's parameter pointer pp  (C callee-saved)
 
   // NOTE: Invocations of builtins may return failure objects
   // instead of a proper result. The builtin entry handles
   // this by performing a garbage collection and retrying the
   // builtin once.
 
-  // Enter C frame
-  // Compute parameter pointer before making changes and save it as ip register
-  // so that it is restored as sp register on exit, thereby popping the args.
-  // ip = sp + kPointerSize*args_len;
-  __ add(ip, sp, Operand(r0, LSL, kPointerSizeLog2));
+  StackFrame::Type frame_type = is_debug_break
+      ? StackFrame::EXIT_DEBUG
+      : StackFrame::EXIT;
 
-  // push in reverse order:
-  // caller_fp, sp_on_exit, caller_pc
-  __ stm(db_w, sp, fp.bit() | ip.bit() | lr.bit());
-  __ mov(fp, Operand(sp));  // setup new frame pointer
-
-  // Store the current context in top.
-  __ mov(ip, Operand(ExternalReference(Top::k_context_address)));
-  __ str(cp, MemOperand(ip));
-
-  // remember top frame
-  __ mov(ip, Operand(ExternalReference(Top::k_c_entry_fp_address)));
-  __ str(fp, MemOperand(ip));
-
-  // Push debug marker.
-  __ mov(ip, Operand(is_debug_break ? 1 : 0));
-  __ push(ip);
+  // Enter the exit frame that transitions from JavaScript to C++.
+  __ EnterExitFrame(frame_type);
 
   if (is_debug_break) {
     // Save the state of all registers to the stack from the memory location.
     // Use sp as base to push.
     __ CopyRegistersFromMemoryToStack(sp, kJSCallerSaved);
   }
 
-  // move number of arguments (argc) into callee-saved register
-  __ mov(r4, Operand(r0));
-
-  // move pointer to builtin function into callee-saved register
-  __ mov(r5, Operand(r1));
-
-  // r0: result parameter for PerformGC, if any (setup below)
   // r4: number of arguments
   // r5: pointer to builtin function  (C callee-saved)
 
   Label entry;
   __ bind(&entry);
 
   Label throw_out_of_memory_exception;
   Label throw_normal_exception;
 
 #ifdef DEBUG
@@ skipping 2789 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = ArmCodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal